Yuck String Math or What's wrong with FOO?

[MWheatley]

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.  ;)

Out of interest, what sort of things do you use LONGs for?

Malcolm

[bplus]

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.  ;)

Out of interest, what sort of things do you use LONGs for?

Malcolm

Signed INTEGERs only have a range of -32,7678 to 32,767 whereas LONG has a range of about 10 digits.

If you just squared the width of a screen you are likely to exceed INTEGER range.

[Pete]

I use LONG in my String Math routine, as LEN() is limited by the LONG variable type limits. Oh, speaking of which, I posted the latest version here: https://www.tapatalk.com/groups/qbasic/viewtopic.php?f=648955&t=39442&p=212636#p212636

Pete

[Pete]

Well, I'm a little bit excited about the first unit testing results in my string math routine. I've ran it a 10 times with all good results. It will pause when a potential problem arises, but, so far, all of those seem to be generated from the higher degree of accuracy with more digits used in many of the string math operations. The pause at least allows me to view and compare, and so far, so good. I'm only using 17+ digits for now. If the first 12 of the 16 digit QB numeric result matches the string math result, it counts it as accepted and moves on. If not, it pauses.

Here is a screen shot where it paused on a 17 digit limit, rounding enabled. I checked in on a calculator to see if it missed a rounding opportunity, and as you can see, it actually didn't!

  [ You are not allowed to view this attachment ]  

So far, I've only tested limits between 17 to 140 digits, rounding enabled, show rounding, and no to everything else. Here's the code I'm testing. Press any key, if it pauses, to keep testing. If anyone does test it and finds a fail, please take a screen shot and post it. Also, let me know the parameters you tested it with, especially the digit limit.

Code: QB64: [Select]

1. WIDTH 156, 43
2. _SCREENMOVE 0, 0
3. PRINT
4. INPUT "Limit Display: "; limit&&
5. LINE INPUT "Use Rounding? Y/N: "; ans$
6. IF UCASE$(ans$) = "Y" THEN
7.     round_total% = -1
8.     LINE INPUT "Show if Rounded? Y/N: "; ans$
9.     IF UCASE$(ans$) = "Y" THEN show_rounding% = -1 ELSE show_rounding% = 0
10. ELSE
11.     round_total% = 0
12. END IF
13. LINE INPUT "Display in Scientific Notation? Y/N: "; ans$
14. IF UCASE$(ans$) = "Y" THEN
15.     snconvert% = -1
16. ELSE
17.     snconvert% = 0
18.     LINE INPUT "Display in Dollars and Cents? Y/N: "; ans$
19.     IF UCASE$(ans$) = "Y" THEN currency_display% = -1 ELSE currency_display% = 0
20.     LINE INPUT "Display Results with Commas? Y/N: "; ans$
21. END IF
22. IF UCASE$(ans$) = "Y" THEN comma_display% = -1 ELSE comma_display% = 0
23. DO
24.     DO
25.         '''LINE INPUT "Number: "; stringmathb$
26.         ' UNIT TESTING============================
27.         stringmathb$ = LTRIM$(STR$(RND * 1000000))
28.         '=========================================
29.         IF UCASE$(stringmathb$) = "C" THEN RUN
30.         origb$ = stringmathb$
31.         CALL stringmath(stringmatha$, operator$, stringmathb$, runningtotal$, snconvert%, round_total%, show_rounding%, comma_display%, currency_display%, limit&&)
32.         IF stringmathb$ <> "invalid number" AND stringmathb$ <> "overflow" THEN
33.             EXIT DO
34.         ELSE
35.             ' UNIT TESTING============================
36.             IF stringmathb$ = "overflow" THEN
37.                 operator% = RND * 3
38.                 SELECT CASE operator%
39.                     CASE 0: operator$ = "+"
40.                     CASE 1: operator$ = "-"
41.                     CASE 2: operator$ = "*"
42.                     CASE 3: operator$ = "/"
43.                 END SELECT
44.                 PRINT stringmathb$
45.                 PRINT "Change Operator: "; operator$: orig_operator$ = operator$
46.                 ' UNIT TESTING============================
47.                 ''' PRINT stringmathb$
48.             ELSE
49.                 PRINT stringmathb$
50.                 END
51.             END IF
52.         END IF
53.     LOOP
54.     IF operator$ <> "" THEN
55.         DO UNTIL INSTR(origa$, ",") = 0
56.             origa$ = MID$(origa$, 1, INSTR(origa$, ",") - 1) + MID$(origa$, INSTR(origa$, ",") + 1)
57.         LOOP
58.         DO UNTIL INSTR(origb$, ",") = 0
59.             origb$ = MID$(origb$, 1, INSTR(origb$, ",") - 1) + MID$(origb$, INSTR(origb$, ",") + 1)
60.         LOOP
61.         IF INSTR(origb$, "$") THEN origb$ = MID$(origb$, 1, INSTR(origb$, "$") - 1) + MID$(origb$, INSTR(origb$, "$") + 1)
62.         SELECT CASE orig_operator$
63.             CASE "+"
64.                 runningtotal# = VAL(origa$) + VAL(origb$)
65.             CASE "-"
66.                 runningtotal# = VAL(origa$) - VAL(origb$)
67.             CASE "*"
68.                 runningtotal# = VAL(origa$) * VAL(origb$)
69.             CASE "/"
70.                 runningtotal# = VAL(origa$) / VAL(origb$)
71.             CASE "C", "c"
72.                 RUN
73.         END SELECT
74.         origa$ = LTRIM$(STR$(runningtotal#))
75.         COLOR 8, 0: PRINT "Numeric Total: "; origa$: COLOR 7, 0
76.         PRINT "String Total:  "; runningtotal$
77.         ' UNIT TESTING============================
78.         q1$ = LTRIM$(STR$(runningtotal#))
79.         q2$ = runningtotal$
80.         IF INSTR(q1$, ".") THEN q1$ = MID$(q1$, 1, INSTR(q1$, ".") - 1) + MID$(q1$, INSTR(q1$, ".") + 1)
81.         IF INSTR(q2$, ".") THEN q2$ = MID$(q2$, 1, INSTR(q2$, ".") - 1) + MID$(q2$, INSTR(q2$, ".") + 1)
82.         IF RIGHT$(UCASE$(q2$), 1) = "R" THEN q2$ = MID$(q2$, 1, LEN(q2$) - 1)
83.         FOR i% = 1 TO 12
84.             IF MID$(q1$, i%, 1) <> MID$(q2$, i%, 1) THEN
85.                  DO
86.                      _LIMIT 10
87.                  LOOP UNTIL INKEY$ <> ""
88.             EXIT FOR
89.             END IF
90.         NEXT
91.         '===========================================
92.     ELSE
93.         origa$ = runningtotal$: IF INSTR(origa$, "$") THEN origa$ = MID$(origa$, 1, INSTR(origa$, "$") - 1) + MID$(origa$, INSTR(origa$, "$") + 1)
94.     END IF
95.     COLOR 2, 0: PRINT "Operator: +-/*: ";: COLOR 7, 0
96.     DO
97.         operator% = RND * 3
98.         SELECT CASE operator%
99.             CASE 0: operator$ = "+"
100.             CASE 1: operator$ = "-"
101.             CASE 2: operator$ = "*"
102.             CASE 3: operator$ = "/"
103.         END SELECT
104.         EXIT DO
105.  
106.         operator$ = INKEY$
107.         IF LEN(operator$) THEN
108.             IF operator$ = CHR$(27) THEN SYSTEM
109.             IF INSTR("-+/*=8cC", operator$) THEN EXIT DO
110.         END IF
111.     LOOP
112.     IF UCASE$(operator$) = "C" THEN RUN
113.     IF operator$ = "=" THEN operator$ = "+"
114.     IF operator$ = "8" THEN operator$ = "*"
115.     orig_operator$ = operator$
116.     PRINT operator$
117. LOOP
118.  
119. SUB stringmath (stringmatha$, operator$, stringmathb$, runningtotal$, snconvert%, round_total%, show_rounding%, comma_display%, currency_display%, limit&&)
120. stringmathround$ = ""
121. IF limit&& > 2147483640 THEN limit&& = 2147483640
122. IF limit&& = 0 THEN limit&& = 70 ' Default.
123.  
124. IF RIGHT$(UCASE$(runningtotal$), 1) = "R" THEN runningtotal$ = MID$(runningtotal$, 1, LEN(runningtotal$) - 1) 'Strip off rounding designation.
125. ' Check running total. If S.N. convert to numeric for operations.
126. IF INSTR(runningtotal$, ",") <> 0 OR INSTR(runningtotal$, "e") <> 0 THEN
127.     holdstringmathb$ = stringmathb$
128.     stringmathb$ = runningtotal$
129.     IF INSTR(runningtotal$, ",") <> 0 THEN GOSUB comma_removal ELSE GOSUB scientific_to_numeric
130.     runningtotal$ = stringmathb$: stringmathb$ = holdstringmathb$: holdstringmathb$ = ""
131. END IF
132. ' Check input number. If S.N. convert to numeric for operations.
133. IF INSTR(UCASE$(stringmathb$), "D") <> 0 OR INSTR(UCASE$(stringmathb$), "E") <> 0 THEN
134.     GOSUB validate_string_number
135.     IF stringmathb$ = "invalid number" THEN EXIT SUB
136.     GOSUB scientific_to_numeric
137. END IF
138.  
139. IF runningtotal$ = "" THEN
140.     GOSUB validate_string_number
141.     IF stringmathb$ = "invalid number" THEN EXIT SUB
142.  
143.     IF LEFT$(stringmathb$, 1) = "-" THEN
144.         stringmathb$ = MID$(stringmathb$, 2)
145.         n2sign$ = "-"
146.     ELSE
147.         n2sign$ = ""
148.     END IF
149.     GOSUB limit_round_convert
150.     IF stringmathb$ = "overflow" THEN
151.         n2sign$ = "": PRINT "Validated: "; stringmathb$: EXIT SUB
152.     END IF
153.     runningtotal$ = n2sign$ + stringmathb$: n2sign$ = ""
154.     IF stringmathround$ <> "" THEN runningtotal$ = runningtotal$ + stringmathround$
155.     PRINT "Validated: "; runningtotal$
156.     IF INSTR(LCASE$(stringmathb$), "e") <> 0 THEN BEEP: GOSUB scientific_to_numeric
157. ELSE
158.     GOSUB validate_string_number
159.     PRINT "Validated: "; stringmathb$
160.     IF stringmathb$ = "invalid number" THEN EXIT SUB
161.     IF INSTR(UCASE$(stringmathb$), "e") <> 0 THEN GOSUB scientific_to_numeric
162. END IF
163. IF runningtotal$ <> "" THEN stringmatha$ = runningtotal$
164.  
165. SELECT CASE operator$
166.     CASE "+", "-"
167.         string_add_subtract:
168.         IF INSTR(stringmatha$, ".") <> 0 THEN ' Evaluate sum for decimal fraction.
169.             sumplace& = LEN(stringmatha$) - INSTR(stringmatha$, ".")
170.             stringmatha$ = MID$(stringmatha$, 1, INSTR(stringmatha$, ".") - 1) + MID$(stringmatha$, INSTR(stringmatha$, ".") + 1) ' Strip out decimal
171.         END IF
172.         IF INSTR(stringmathb$, ".") <> 0 THEN ' Evaluate number for decimal fraction.
173.             numplace& = LEN(stringmathb$) - INSTR(stringmathb$, ".")
174.             stringmathb$ = MID$(stringmathb$, 1, INSTR(stringmathb$, ".") - 1) + MID$(stringmathb$, INSTR(stringmathb$, ".") + 1) ' Strip out decimal
175.         END IF
176.         IF sumplace& > numplace& THEN addsubplace& = sumplace& ELSE addsubplace& = numplace&
177.         IF sumplace& > addsubplace& THEN
178.             stringmatha$ = stringmatha$ + STRING$(sumplace& - addsubplace&, "0")
179.         ELSEIF addsubplace& > sumplace& THEN
180.             stringmatha$ = stringmatha$ + STRING$(addsubplace& - sumplace&, "0")
181.         END IF
182.         IF numplace& > addsubplace& THEN
183.             stringmathb$ = stringmathb$ + STRING$(numplace& - addsubplace&, "0")
184.         ELSEIF addsubplace& > numplace& THEN
185.             stringmathb$ = stringmathb$ + STRING$(addsubplace& - numplace&, "0")
186.         END IF ' END Decimal evaluations.
187.  
188.         IF LEFT$(stringmatha$, 1) = "-" THEN sign_input$ = "-" ELSE sign_input$ = "+"
189.         IF LEFT$(stringmathb$, 1) = "-" THEN sign_total$ = "-" ELSE sign_total$ = "+"
190.  
191.         addsubsign% = 0
192.         SELECT CASE sign_input$ + operator$ + sign_total$
193.             CASE "+++", "+--"
194.                 operator$ = "+"
195.                 IF LEFT$(stringmathb$, 1) = "-" THEN stringmathb$ = MID$(stringmathb$, 2)
196.             CASE "++-", "+-+"
197.                 operator$ = "-"
198.                 IF LEFT$(stringmathb$, 1) = "-" THEN stringmathb$ = MID$(stringmathb$, 2)
199.                 IF VAL(stringmathb$) > VAL(stringmatha$) THEN SWAP stringmatha$, stringmathb$: addsubsign% = -1
200.             CASE "---", "-++"
201.                 operator$ = "-"
202.                 IF LEFT$(stringmatha$, 1) = "-" THEN stringmatha$ = MID$(stringmatha$, 2)
203.                 IF LEFT$(stringmathb$, 1) = "-" THEN stringmathb$ = MID$(stringmathb$, 2)
204.                 IF VAL(stringmathb$) > VAL(stringmatha$) THEN SWAP stringmatha$, stringmathb$ ELSE addsubsign% = -1
205.             CASE "--+", "-+-"
206.                 operator$ = "+"
207.                 IF LEFT$(stringmatha$, 1) = "-" THEN stringmatha$ = MID$(stringmatha$, 2)
208.                 IF LEFT$(stringmathb$, 1) = "-" THEN stringmathb$ = MID$(stringmathb$, 2)
209.                 addsubsign% = -1
210.         END SELECT
211.  
212.         IF LEN(stringmatha$) > LEN(stringmathb$) THEN
213.             stringmathb$ = STRING$(LEN(stringmatha$) - LEN(stringmathb$), "0") + stringmathb$
214.         ELSEIF LEN(stringmatha$) < LEN(stringmathb$) THEN
215.             stringmatha$ = STRING$(LEN(stringmathb$) - LEN(stringmatha$), "0") + stringmatha$
216.         END IF
217.         addsubx1$ = ""
218.  
219.         SELECT CASE operator$
220.             CASE "+", "="
221.                 FOR addsubii& = LEN(stringmatha$) TO 1 STEP -1
222.                     addsubx1% = VAL(MID$(stringmatha$, addsubii&, 1)) + VAL(MID$(stringmathb$, addsubii&, 1)) + addsubcarry%
223.                     IF addsubx1% > 9 THEN addsubx1% = addsubx1% - 10: addsubcarry% = 1 ELSE addsubcarry% = 0
224.                     addsubx1$ = LTRIM$(STR$(addsubx1%)) + addsubx1$
225.                 NEXT
226.                 IF addsubcarry% THEN addsubx1$ = "1" + addsubx1$: addsubcarry% = 0
227.                 GOSUB replace_decimal
228.             CASE "-"
229.                 FOR addsubii& = LEN(stringmatha$) TO 1 STEP -1
230.                     addsubx1% = VAL(MID$(stringmatha$, addsubii&, 1)) - VAL(MID$(stringmathb$, addsubii&, 1)) + addsubcarry%
231.                     IF addsubx1% < 0 THEN addsubx1% = addsubx1% + 10: addsubcarry% = -1 ELSE addsubcarry% = 0
232.                     addsubx1$ = LTRIM$(STR$(addsubx1%)) + addsubx1$
233.                 NEXT
234.                 IF addsubx1$ <> "" AND addsubx1$ <> STRING$(LEN(addsubx1$), "0") THEN GOSUB replace_decimal
235.                 DO UNTIL LEFT$(addsubx1$, 1) <> "0" ' Remove leading zeros.
236.                     addsubx1$ = MID$(addsubx1$, 2)
237.                 LOOP
238.                 IF addsubx1$ = "" THEN
239.                     addsubx1$ = "0": addsubsign% = 0
240.                 ELSE
241.                     IF addsubcarry% THEN addsubx1$ = "-" + addsubx1$: addsubcarry% = 0
242.                 END IF
243.         END SELECT
244.  
245.         IF addsubsign% THEN
246.             IF LEFT$(addsubx1$, 1) = "-" THEN addsubx1$ = MID$(addsubx1$, 2) ELSE addsubx1$ = "-" + addsubx1$
247.         END IF
248.         stringmatha$ = addsubx1$: addsubx1$ = ""
249.         IF operationdivision% THEN RETURN
250.         stringmathb$ = stringmatha$: stringmatha$ = ""
251.         IF LEFT$(stringmathb$, 1) = "-" THEN
252.             stringmathb$ = MID$(stringmathb$, 2)
253.             n2sign$ = "-"
254.         ELSE
255.             n2sign$ = ""
256.         END IF
257.         GOSUB limit_round_convert
258.         IF stringmathb$ = "overflow" THEN n2sign$ = "": EXIT SUB
259.         GOSUB sm_converter
260.         runningtotal$ = n2sign$ + stringmathb$: n2sign$ = ""
261.  
262.     CASE "*"
263.         string_multiply:
264.         fac1$ = stringmatha$: fac2$ = stringmathb$ ' Make numbers whole numbers and remove any - sign.
265.         IF LEFT$(fac1$, 1) = "-" THEN fac1$ = MID$(fac1$, 2): m_sign% = -1
266.         IF LEFT$(fac2$, 1) = "-" THEN fac2$ = MID$(fac2$, 2): IF m_sign% THEN m_sign% = 0 ELSE m_sign% = -1
267.         IF INSTR(fac1$, ".") <> 0 THEN m_decimal_places& = LEN(fac1$) - INSTR(fac1$, "."): fac1$ = MID$(fac1$, 1, INSTR(fac1$, ".") - 1) + MID$(fac1$, INSTR(fac1$, ".") + 1)
268.         IF INSTR(fac2$, ".") <> 0 THEN m_decimal_places& = m_decimal_places& + LEN(fac2$) - INSTR(fac2$, "."): fac2$ = MID$(fac2$, 1, INSTR(fac2$, ".") - 1) + MID$(fac2$, INSTR(fac2$, ".") + 1)
269.         FOR m_i& = LEN(fac2$) TO 1 STEP -1 ' Multiply each charter top and bottom.
270.             m_k& = m_l&
271.             m_x2$ = MID$(fac2$, m_i&, 1)
272.             FOR m_j& = LEN(fac1$) TO 1 STEP -1
273.                 m_x1$ = MID$(fac1$, m_j&, 1)
274.                 IF m_product$ <> "" THEN
275.                     m_add$ = LTRIM$(STR$(VAL(m_x1$) * VAL(m_x2$))) + STRING$(m_k&, "0")
276.                     m_t& = 0: m_xproduct$ = "": m_carry% = 0
277.                     DO ' Add multiplied characters together.
278.                         m_x3$ = MID$(m_add$, LEN(m_add$) - m_t&, 1)
279.                         m_x4$ = MID$(m_product$, LEN(m_product$) - m_t&, 1)
280.                         IF m_x3$ = "" AND m_x4$ = "" THEN
281.                             IF m_carry% THEN m_xproduct$ = "1" + m_xproduct$
282.                             EXIT DO
283.                         END IF
284.                         m_g% = VAL(m_x3$) + VAL(m_x4$) + m_carry%
285.                         IF m_g% >= 10 THEN m_g% = m_g% - 10: m_carry% = 1 ELSE m_carry% = 0
286.                         m_xproduct$ = LTRIM$(STR$(m_g%)) + m_xproduct$
287.                         m_t& = m_t& + 1
288.                     LOOP
289.                     m_product$ = m_xproduct$: m_xproduct$ = ""
290.                 ELSE
291.                     m_product$ = LTRIM$(STR$(VAL(m_x1$) * VAL(m_x2$))) + STRING$(m_k&, "0") ' First loop makes variable here.
292.                 END IF
293.                 m_k& = m_k& + 1 ' Adds trailing zeros multiplication
294.             NEXT
295.             m_l& = m_l& + 1 ' Used to reset value for m_k& adding one trailing zer for each loop.
296.         NEXT
297.         fac1$ = "": fac2$ = "": m_l& = 0: m_k& = 0: m_t& = 0
298.         IF m_decimal_places& > LEN(m_product$) THEN m_product$ = STRING$(m_decimal_places& - LEN(m_product$), "0") + m_product$ ' Add any leading zeros to a decimal. Ex: .02 * .01 is factored as 002. It needs one leading zero before adding the decimal point, .0002.
299.         IF m_decimal_places& AND m_product$ <> "0" THEN ' Replace any decimal point.
300.             m_product$ = MID$(m_product$, 1, LEN(m_product$) - m_decimal_places&) + "." + MID$(m_product$, LEN(m_product$) - m_decimal_places& + 1)
301.         END IF
302.         DO UNTIL LEFT$(m_product$, 1) <> "0" ' Remove leading zeros.
303.             m_product$ = MID$(m_product$, 2)
304.         LOOP
305.         IF m_decimal_places& THEN
306.             DO UNTIL RIGHT$(m_product$, 1) <> "0" ' Remove trailing zeros in a decimal sum.
307.                 m_product$ = MID$(m_product$, 1, LEN(m_product$) - 1)
308.             LOOP
309.         END IF
310.         IF m_product$ = "" THEN m_product$ = "0": m_sign% = 0
311.         IF RIGHT$(m_product$, 1) = "." THEN m_product$ = MID$(m_product$, 1, LEN(m_product$) - 1) ' Remove decimal from the end of an integer total.
312.         IF operationdivision% THEN m_sign% = 0: RETURN
313.         stringmathb$ = m_product$: m_product$ = "": GOSUB limit_round_convert
314.         IF stringmathb$ = "overflow" THEN EXIT SUB
315.         GOSUB sm_converter
316.         runningtotal$ = stringmathb$: stringmathb$ = ""
317.         IF m_sign% THEN runningtotal$ = "-" + runningtotal$: m_sign% = 0
318.  
319.     CASE "/"
320.         operationdivision% = -1
321.         divbuffer& = LEN(stringmathb$) - LEN(stringmatha$)
322.         IF divbuffer& < 0 THEN divbuffer& = 0
323.         d2dividend$ = stringmatha$
324.         d1divisor$ = stringmathb$
325.         IF LEFT$(d1divisor$, 1) = "0" AND LEN(d1divisor$) = 1 THEN PRINT "Division by zero not allowed.": END
326.         IF LEFT$(d1divisor$, 1) = "-" THEN divsign% = -1: d1divisor$ = MID$(d1divisor$, 2)
327.         IF LEFT$(d2dividend$, 1) = "-" THEN
328.             IF divsign% THEN
329.                 divsign% = 0
330.             ELSE
331.                 divsign% = -1
332.             END IF
333.             d2dividend$ = MID$(d2dividend$, 2)
334.         END IF
335.         IF INSTR(d1divisor$, ".") <> 0 THEN
336.             DO UNTIL RIGHT$(d1divisor$, 1) <> "0"
337.                 d1divisor$ = MID$(d1divisor$, 1, LEN(d1divisor$) - 1) ' Strip off trailing zeros
338.             LOOP
339.             divplace& = LEN(d1divisor$) - INSTR(d1divisor$, ".")
340.             d1divisor$ = MID$(d1divisor$, 1, INSTR(d1divisor$, ".") - 1) + MID$(d1divisor$, INSTR(d1divisor$, ".") + 1) ' Strip off decimal point.
341.             DO UNTIL LEFT$(d1divisor$, 1) <> "0"
342.                 d1divisor$ = MID$(d1divisor$, 2) ' Strip off leading zeros for divisors smaller than .1
343.             LOOP
344.         END IF
345.  
346.         IF INSTR(d2dividend$, ".") <> 0 THEN
347.             d2dividend$ = d2dividend$ + STRING$(divplace& - LEN(d2dividend$) - INSTR(d2dividend$, "."), "0") ' Add any zeros based on the length of dividend at decimal - length of divisor at decimal. If less than zero, nothing added.
348.             divplace2& = INSTR(d2dividend$, ".")
349.             DO UNTIL RIGHT$(d2dividend$, 1) <> "0"
350.                 d2dividend$ = MID$(d2dividend$, 1, LEN(d2dividend$) - 1) ' Strip off trailing zeros
351.             LOOP
352.             d2dividend$ = MID$(d2dividend$, 1, INSTR(d2dividend$, ".") - 1) + MID$(d2dividend$, INSTR(d2dividend$, ".") + 1) ' Strip off decimal point.
353.         ELSE
354.             d2dividend$ = d2dividend$ + 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.
355.             divplace& = 0
356.         END IF
357.         DO
358.             DO
359.                 divremainder& = divremainder& + 1: divremainder$ = divremainder$ + MID$(d2dividend$, divremainder&, 1)
360.                 IF MID$(d2dividend$, divremainder&, 1) = "" THEN
361.                     IF divremainder$ = STRING$(LEN(divremainder$), "0") AND LEN(quotient$) > LEN(d2dividend$) THEN divflag% = -1: EXIT DO
362.                     divcarry& = divcarry& + 1
363.                     IF divcarry& = 1 THEN divplace3& = divremainder& - 1
364.                     IF divcarry& > limit&& + 1 + divbuffer& THEN
365.                         divflag% = -2: EXIT DO
366.                     END IF
367.                     divremainder$ = divremainder$ + "0" ' No more digits to bring down.
368.                 END IF
369.                 IF LEN(divremainder$) > LEN(d1divisor$) OR LEN(divremainder$) = LEN(d1divisor$) AND divremainder$ >= d1divisor$ THEN EXIT DO
370.                 quotient$ = quotient$ + "0"
371.             LOOP
372.             IF divflag% THEN divflag% = 0: EXIT DO
373.             FOR div_i% = 9 TO 1 STEP -1
374.                 stringmatha$ = LTRIM$(STR$(div_i%)): stringmathb$ = d1divisor$
375.                 m_product$ = "": GOSUB string_multiply
376.                 tempcutd$ = divremainder$ ' divremainder$ can be 00 or other leading zero values.
377.                 DO
378.                     IF LEN(tempcutd$) = 1 THEN EXIT DO
379.                     IF LEFT$(tempcutd$, 1) = "0" THEN
380.                         tempcutd$ = MID$(tempcutd$, 2)
381.                     ELSE
382.                         EXIT DO
383.                     END IF
384.                 LOOP
385.                 IF LEN(tempcutd$) > LEN(m_product$) OR LEN(tempcutd$) = LEN(m_product$) AND m_product$ <= tempcutd$ THEN EXIT FOR
386.             NEXT
387.             quotient$ = quotient$ + LTRIM$(STR$(div_i%))
388.             stringmatha$ = LTRIM$(STR$(div_i%)): stringmathb$ = d1divisor$
389.             m_product$ = "": GOSUB string_multiply
390.             operator$ = "-"
391.             stringmatha$ = divremainder$
392.             stringmathb$ = m_product$
393.             GOSUB string_add_subtract
394.             divremainder$ = stringmatha$
395.             operator$ = "/"
396.         LOOP
397.         IF divplace& = 0 AND divplace2& = 0 THEN divplace& = divplace3&
398.         IF divplace2& THEN divplace& = divplace& + divplace2& - 1
399.         IF quotient$ = "" THEN divplace& = 0 ' dividend is zero.
400.         IF divplace& OR divplace2& THEN
401.             quotient$ = MID$(quotient$, 1, divplace&) + "." + MID$(quotient$, divplace& + 1)
402.             DO UNTIL RIGHT$(quotient$, 1) <> "0"
403.                 quotient$ = MID$(quotient$, 1, LEN(quotient$) - 1) ' Strip off trailing zeros
404.             LOOP
405.             IF RIGHT$(quotient$, 1) = "." THEN quotient$ = MID$(quotient$, 1, LEN(quotient$) - 1) ' Strip off abandoned decimal.
406.         END IF
407.         DO UNTIL LEFT$(quotient$, 1) <> "0"
408.             quotient$ = MID$(quotient$, 2) ' Strip off leading zeros
409.         LOOP
410.         IF quotient$ = "" THEN quotient$ = "0": divsign% = 0
411.         operationdivision% = 0
412.         stringmathb$ = quotient$: quotient$ = "": GOSUB limit_round_convert
413.         IF stringmathb$ = "overflow" THEN divsign% = 0: EXIT SUB
414.         GOSUB sm_converter
415.         runningtotal$ = stringmathb$: stringmathb$ = ""
416.         IF divsign% THEN runningtotal$ = "-" + runningtotal$
417. END SELECT
418. IF stringmathround$ <> "" THEN runningtotal$ = runningtotal$ + stringmathround$
419. EXIT SUB
420.  
421. validate_string_number:
422. vsn_negcnt& = 0: vsn_poscnt& = 0: vsn_depresent& = 0: decimalcnt& = 0: vsn_numberpresent& = 0: vsn_zerospresent& = 0
423. IF LEFT$(stringmathb$, 1) = "-" THEN stringmathb$ = MID$(stringmathb$, 2): sm_sign$ = "-" ELSE sm_sign$ = ""
424. IF LEFT$(stringmathb$, 1) = "+" THEN IF sm_sign$ <> "-" THEN stringmathb$ = MID$(stringmathb$, 2) ELSE stringmathb$ = "invalid number": RETURN
425. IF INSTR(UCASE$(stringmathb$), "D") OR INSTR(UCASE$(stringmathb$), "E") THEN ' Evaluate for Scientific Notation.
426.     FOR sm_i& = 1 TO LEN(stringmathb$)
427.         validatenum$ = MID$(UCASE$(stringmathb$), sm_i&, 1)
428.         SELECT CASE validatenum$
429.             CASE "+"
430.                 IF vsn_depresent& THEN vsn_poscnt& = vsn_poscnt& + 1 ELSE stringmathb$ = "invalid number": RETURN
431.             CASE "-"
432.                 IF vsn_depresent& THEN vsn_negcnt& = vsn_negcnt& + 1 ELSE stringmathb$ = "invalid number": RETURN
433.             CASE "0" TO "9"
434.                 vsn_numberpresent& = -1
435.             CASE "D", "E"
436.                 vsn_depresent& = vsn_depresent& + 1
437.                 IF decimalcnt& = 0 AND sm_i& <> 2 OR vsn_depresent& > 1 OR vsn_numberpresent& = 0 OR vsn_negcnt& > 1 OR vsn_poscnt& > 1 OR vsn_negcnt& = 1 AND vsn_poscnt& >= 1 THEN vsn_numberpresent& = 0: EXIT FOR
438.                 vsn_numberpresent& = 0
439.                 MID$(stringmathb$, sm_i&, 1) = "e" ' Standardize
440.             CASE "."
441.                 decimalcnt& = decimalcnt& + 1
442.                 IF sm_i& <> 2 THEN vsn_numberpresent& = 0: EXIT FOR
443.             CASE ELSE
444.                 vsn_numberpresent& = 0: EXIT FOR
445.         END SELECT
446.     NEXT
447.     IF decimalcnt& = 0 THEN stringmathb$ = MID$(stringmathb$, 1, 1) + "." + MID$(stringmathb$, 2) ' Standardize "."
448.     IF vsn_numberpresent& = 0 OR vsn_negcnt& = 1 AND vsn_poscnt& = 1 OR decimalcnt& > 1 OR INSTR(stringmathb$, ".") <> 2 THEN stringmathb$ = "invalid number": RETURN
449.     vsn_depresent& = INSTR(stringmathb$, "e")
450.     sm_x$ = MID$(stringmathb$, vsn_depresent& + 1, 1) ' Standardize exponent "+" these two lines.
451.     IF sm_x$ <> "+" AND sm_x$ <> "-" THEN stringmathb$ = MID$(stringmathb$, 1, vsn_depresent&) + "+" + MID$(stringmathb$, vsn_depresent& + 1)
452.     IF MID$(stringmathb$, vsn_depresent& + 2, 1) = "0" THEN
453.         IF MID$(stringmathb$, vsn_depresent& + 3, 1) <> "" THEN stringmathb$ = "invalid number": RETURN ' No leading zeros allowed in exponent notation.
454.     END IF
455.     jjed& = INSTR(stringmathb$, "e") ' Get position of notation.
456.     valexpside$ = MID$(stringmathb$, jjed&) ' These two lines break up into number and notation
457.     stringmathb$ = MID$(stringmathb$, 1, jjed& - 1) ' stringmathb$ is +- single digit whole number, decimal point and decimal number. valexpside$ is notation, sign and exponent.
458.     DO UNTIL RIGHT$(stringmathb$, 1) <> "0" ' Remove any trailing zeros for number. Example 1.0d3 or 1.0000d3, etc.
459.         stringmathb$ = MID$(stringmathb$, 1, LEN(stringmathb$) - 1)
460.     LOOP
461.     IF VAL(MID$(stringmathb$, 1, INSTR(stringmathb$, ".") - 1)) = 0 THEN
462.         IF RIGHT$(stringmathb$, 1) = "." THEN
463.             stringmathb$ = "0.e+0" ' Handles all types of zero entries.
464.         ELSE
465.             stringmathb$ = "invalid number": RETURN
466.         END IF
467.         RETURN
468.     END IF
469.     stringmathb$ = sm_sign$ + stringmathb$ + valexpside$
470.     RETURN
471. ELSE
472.     FOR sm_i& = 1 TO LEN(stringmathb$)
473.         validatenum$ = MID$(stringmathb$, sm_i&, 1)
474.         SELECT CASE validatenum$
475.             CASE "."
476.                 decimalcnt& = decimalcnt& + 1
477.             CASE "0"
478.                 vsn_zerospresent& = -1
479.             CASE "1" TO "9"
480.                 vsn_numberpresent& = -1
481.             CASE "$"
482.             CASE ELSE
483.                 stringmathb$ = "invalid number": RETURN
484.         END SELECT
485.     NEXT
486.     IF decimalcnt& > 1 OR vsn_negcnt& > 1 OR vsn_poscnt& > 1 OR vsn_negcnt& >= 1 AND vsn_poscnt& >= 1 THEN
487.         stringmathb$ = "invalid number": RETURN
488.     END IF
489.     IF INSTR(stringmathb$, "$") THEN GOSUB currency_validate
490.     IF INSTR(stringmathb$, ",") THEN
491.         GOSUB comma_validation
492.         IF stringmathb$ = "invalid number" THEN RETURN
493.         GOSUB comma_removal
494.     END IF
495.     IF RIGHT$(stringmathb$, 1) = "." THEN stringmathb$ = MID$(stringmathb$, 1, LEN(stringmathb$) - 1)
496.     DO UNTIL LEFT$(stringmathb$, 1) <> "0" ' Strip off any leading zeros.
497.         stringmathb$ = MID$(stringmathb$, 2)
498.     LOOP
499.     stringmathb$ = sm_sign$ + stringmathb$
500.     IF INSTR(stringmathb$, ".") THEN
501.         DO UNTIL RIGHT$(stringmathb$, 1) <> "0" ' Strip off any trailing zeros in a decimal.
502.             stringmathb$ = MID$(stringmathb$, 1, LEN(stringmathb$) - 1)
503.         LOOP
504.     END IF
505.     IF RIGHT$(stringmathb$, 1) = "." THEN stringmathb$ = MID$(stringmathb$, 1, LEN(stringmathb$) - 1)
506.     IF vsn_numberpresent& = 0 THEN
507.         IF vsn_zerospresent& THEN
508.             stringmathb$ = "0"
509.         ELSE
510.             stringmathb$ = "invalid number"
511.         END IF
512.     END IF
513. END IF
514. RETURN
515.  
516. ' Convert to commas, currency, S.N., etc.
517. sm_converter:
518. IF comma_display% THEN GOSUB comma_placement
519. IF currency_display% THEN GOSUB currency_convert
520. IF snconvert% THEN GOSUB numeric_to_scientific
521. RETURN
522.  
523. ' Add in commas.
524. comma_placement:
525. GOSUB comma_prep
526. sm_i& = 0: sm_j& = 0: sm_seed& = 0
527. sm_seed& = LEN(temp_stringmathb1$) MOD 3: IF sm_seed& = 0 THEN sm_seed& = 3
528. sm_m1& = LEN(temp_stringmathb1$)
529. sm_m2& = (LEN(temp_stringmathb1$) - 1) \ 3
530. sm_replace$ = SPACE$(sm_m1& + sm_m2&)
531. DO WHILE sm_i& < sm_m1&
532.     MID$(sm_replace$, sm_j& + 1, sm_seed& + 1) = MID$(temp_stringmathb1$, sm_i& + 1, sm_seed&) + ","
533.     sm_i& = sm_i& + sm_seed&: sm_j& = sm_j& + sm_seed& + 1: sm_seed& = 3
534. LOOP
535. sm_replace$ = RTRIM$(sm_replace$)
536. IF RIGHT$(sm_replace$, 1) = "," THEN
537.     stringmathb$ = MID$(sm_replace$, 1, LEN(sm_replace$) - 1)
538. ELSE
539.     stringmathb$ = sm_replace$
540. END IF
541. sm_replace$ = "": temp_stringmathb1$ = ""
542. RETURN
543.  
544. ' Validate comma entry.
545. comma_validation:
546. GOSUB comma_prep
547. IF INSTR(temp_stringmathb2$, ",") <> 0 OR temp_stringmathb1$ = STRING$(LEN(temp_stringmathb1$), ",") THEN
548.     stringmathb$ = "invalid number" ' Decimal part has comma or entry is all commas.
549. ELSE
550.     FOR sm_i& = LEN(temp_stringmathb1$) TO 1 STEP -1
551.         sm_j% = sm_j% + 1
552.         IF sm_j% = 4 THEN
553.             IF MID$(temp_stringmathb1$, sm_i&, 1) <> "," THEN stringmathb$ = "invalid number": EXIT FOR
554.             sm_j% = 0
555.         END IF
556.     NEXT
557.     IF stringmathb$ <> "invalid number" THEN
558.         stringmathb$ = sm_sign$ + temp_stringmathb1$ + temp_stringmathb2$
559.     END IF
560. END IF
561. temp_stringmathb1$ = "": temp_stringmathb2$ = "": sm_i& = 0: sm_j% = 0: sm_sign$ = "": sm_dollar$ = ""
562. RETURN
563.  
564. comma_removal:
565. sm_i& = 0: sm_j& = 0: sm_seed& = 0
566. sm_replace$ = SPACE$(LEN(stringmathb$))
567. DO
568.     sm_i& = INSTR(sm_seed& + 1, stringmathb$, ",")
569.     IF sm_i& = 0 THEN EXIT DO
570.     MID$(sm_replace$, sm_j& + 1, sm_i& - sm_seed& + 1) = MID$(stringmathb$, sm_seed& + 1, sm_i& - sm_seed& - 1)
571.     sm_j& = sm_j& + sm_i& - sm_seed& - 1
572.     sm_seed& = sm_i&
573. LOOP
574. stringmathb$ = RTRIM$(sm_replace$) + MID$(stringmathb$, sm_seed& + 1): sm_replace$ = ""
575. RETURN
576.  
577. comma_prep:
578. IF LEFT$(stringmathb$, 1) = "-" THEN stringmathb$ = MID$(stringmathb$, 2): sm_sign$ = "-"
579. temp_stringmathb1$ = stringmathb$: stringmathb$ = ""
580. IF INSTR(temp_stringmathb1$, ".") THEN
581.     temp_stringmathb2$ = MID$(temp_stringmathb1$, INSTR(temp_stringmathb1$, ".")) ' Decimal part
582.     temp_stringmathb1$ = MID$(temp_stringmathb1$, 1, INSTR(temp_stringmathb1$, ".") - 1) ' Non-decimal part
583. END IF
584. IF LEFT$(temp_stringmathb1$, 1) = "$" THEN temp_stringmathb1$ = MID$(temp_stringmathb1$, 2): sm_dollar$ = "$"
585. RETURN
586.  
587. currency_validate:
588. IF LEFT$(stringmathb$, 2) = "$-" OR LEFT$(stringmathb$, 2) = "$+" THEN stringmathb$ = "invalid number": RETURN
589. IF LEFT$(stringmathb$, 1) = "$" THEN stringmathb$ = MID$(stringmathb$, 2)
590. IF INSTR(stringmathb$, "$") THEN stringmathb$ = "invalid number": RETURN
591. sm_dollar$ = "$"
592. RETURN
593.  
594. currency_convert:
595. IF INSTR(UCASE$(stringmathb$), "D") <> 0 OR INSTR(UCASE$(stringmathb$), "E") <> 0 THEN GOSUB scientific_to_numeric
596. IF INSTR(stringmathb$, ",") = 0 THEN GOSUB comma_placement
597. IF INSTR(stringmathb$, ".") = 0 THEN stringmathb$ = stringmathb$ + ".00"
598. IF RIGHT$(stringmathb$, 1) = "." THEN stringmathb$ = stringmathb$ + "00"
599. IF MID$(stringmathb$, LEN(stringmathb$) - 2, 1) <> "." THEN stringmathb$ = stringmathb$ + "0"
600. IF MID$(stringmathb$, LEN(stringmathb$) - 2, 1) <> "." THEN stringmathb$ = "invalid number": RETURN
601. IF LEFT$(stringmathb$, 1) = "-" THEN stringmathb$ = MID$(stringmathb$, 2)
602. stringmathb$ = sm_sign$ + "$" + stringmathb$
603. RETURN
604.  
605. numeric_to_scientific:
606. IF LEFT$(stringmathb$, 1) = "-" THEN stringmathb$ = MID$(stringmathb$, 2): n2sign$ = "-"
607. IF INSTR(stringmathb$, ".") = 0 THEN exponentvalue&& = LEN(stringmathb$) - 1 ELSE exponentvalue&& = INSTR(stringmathb$, ".") - 2 ' Exponent is one less than number of digits for whole number an two less than the placement of the decimal point for a fraction.
608. stringmathb$ = MID$(stringmathb$, 1, INSTR(stringmathb$, ".") - 1) + MID$(stringmathb$, INSTR(stringmathb$, ".") + 1)
609. IF LEFT$(stringmathb$, 1) = "0" AND LEN(stringmathb$) > 1 OR exponentvalue&& = -1 THEN
610.     DO UNTIL LEFT$(stringmathb$, 1) <> "0" ' Remove leading zeros to consider rounding.
611.         stringmathb$ = MID$(stringmathb$, 2)
612.         exponentvalue&& = exponentvalue&& - 1
613.     LOOP
614.     esign$ = "-"
615. ELSE
616.     esign$ = "+"
617. END IF
618. DO UNTIL RIGHT$(stringmathb$, 1) <> "0" ' Remove trailing zeros.
619.     stringmathb$ = MID$(stringmathb$, 1, LEN(stringmathb$) - 1)
620. LOOP
621. IF stringmathb$ = "" THEN stringmathb$ = "0": esign$ = "+": exponentvalue&& = 0
622. stringmathb$ = LEFT$(stringmathb$, 1) + "." + MID$(stringmathb$, 2)
623. IF stringmathb$ = "0." THEN n2sign$ = "": esign$ = "+"
624. stringmathb$ = stringmathb$ + "e" + esign$ + LTRIM$(STR$(ABS(exponentvalue&&))) ' S.N formed here.
625. IF stringmathb$ <> "overflow" THEN
626.     stringmathb$ = n2sign$ + stringmathb$
627. END IF
628. n2sign$ = "": esign$ = "": exponentvalue&& = 0
629. RETURN
630.  
631. scientific_to_numeric:
632. IF INSTR(UCASE$(stringmathb$), "D") THEN MID$(stringmathb$, INSTR(UCASE$(stringmathb$), "D"), 1) = "e"
633. IF MID$(stringmathb$, INSTR(stringmathb$, "e") + 2) = "0" THEN ' The numeric value is the number without the zero exponent.
634.     stringmathb$ = MID$(stringmathb$, 1, INSTR(stringmathb$, "e") - 1)
635.     IF RIGHT$(stringmathb$, 1) = "." THEN stringmathb$ = MID$(stringmathb$, 1, LEN(stringmathb$) - 1)
636.     RETURN
637. ELSE
638.     IF LEFT$(stringmathb$, 1) = "-" THEN stn_sign$ = "-": stringmathb$ = MID$(stringmathb$, 2)
639.     stringmathb$ = MID$(stringmathb$, 1, INSTR(stringmathb$, ".") - 1) + MID$(stringmathb$, INSTR(stringmathb$, ".") + 1) ' Remove decimal point.
640.     stn_i& = INSTR(stringmathb$, "e") - 1 ' Length of the numric part.
641.     IF MID$(stringmathb$, INSTR(stringmathb$, "e") + 1, 1) = "-" THEN
642.         stringmathb$ = "." + STRING$(VAL(MID$(stringmathb$, stn_i& + 3)) - 1, "0") + MID$(stringmathb$, 1, stn_i&) ' Decimal point followed by exponent value in zeros added in front of numeric part.
643.     ELSE
644.         IF stn_i& - 1 > VAL(MID$(stringmathb$, stn_i& + 3)) THEN stn_point$ = "." ' - 1 for decimal place. Ex 2.034d+2 is 2034 here where 3 places to the right . could be moved before . disappears. > so no trailing decimal results.
645.         stringmathb$ = MID$(MID$(stringmathb$, 1, stn_i&), 1, VAL(MID$(stringmathb$, stn_i& + 3)) + 1) + stn_point$ + MID$(MID$(stringmathb$, 1, stn_i&), VAL(MID$(stringmathb$, stn_i& + 3)) + 2, stn_i& - VAL(MID$(stringmathb$, stn_i& + 3)) - 1) + STRING$(VAL(MID$(stringmathb$, stn_i& + 2)) - (stn_i& - 1), "0")
646.     END IF
647. END IF
648. IF stringmathb$ = "0" THEN stn_sign$ = ""
649. stringmathb$ = stn_sign$ + stringmathb$
650. stn_sign$ = "": stn_point$ = ""
651. RETURN
652.  
653. limit_round_convert:
654. ' Try SN if whole number is too large (as it may be trailing zeros) or decimal is beyond limit.
655. IF LEFT$(stringmathb$, 2) = ".0" AND LEN(stringmathb$) > limit&& + 1 OR INSTR(stringmathb$, ".") > limit&& + 1 OR INSTR(stringmathb$, ".") = 0 AND LEN(stringmathb$) > limit&& THEN
656.     IF limit&& > 1 THEN
657.         GOSUB numeric_to_scientific ' Retry as S.N.
658.         IF LEN(stringmathb$) > limit&& + 3 THEN ' Needs rounding.
659.             snotation$ = MID$(stringmathb$, INSTR(UCASE$(stringmathb$), "E"))
660.             exponentvalue&& = VAL(MID$(snotation$, 2)) ' Get positive or negative sign.
661.             snexponent$ = MID$(stringmathb$, INSTR(UCASE$(stringmathb$), "E") + 2)
662.             stringmathb$ = MID$(stringmathb$, 1, INSTR(UCASE$(stringmathb$), "E") - 1)
663.             '''IF LEN(stringmathb$) + LEN(snexponent$) > limit&& + 1 AND exponentvalue&& >= limit&& THEN BEEP
664.             IF exponentvalue&& >= limit&& THEN
665.                 stringmathb$ = MID$(stringmathb$, 1, exponentvalue&& + 3)
666.             ELSE
667.                 stringmathb$ = MID$(stringmathb$, 1, limit&& - LEN(snexponent$) + 2)
668.             END IF
669.             GOSUB string_rounding_method
670.             IF LEFT$(stringmathb$, 3) = "10." THEN
671.                 stringmathb$ = "1." + MID$(stringmathb$, 4)
672.                 ' Add one to the exponent.
673.                 FOR round_i& = LEN(snexponent$) TO 1 STEP -1
674.                     round_x$ = CHR$(ASC(MID$(snexponent$, round_i&, 1)) + 1)
675.                     IF round_x$ <> CHR$(47) THEN ' Decimal point + 1. Ignore.
676.                         IF round_x$ = CHR$(58) THEN
677.                             MID$(snexponent$, round_i&, 1) = "0": carry$ = "1"
678.                         ELSE
679.                             MID$(snexponent$, round_i&, 1) = round_x$: carry$ = "": EXIT FOR
680.                         END IF
681.                     END IF
682.                 NEXT
683.                 snexponent$ = carry$ + snexponent$: carry$ = ""
684.             END IF
685.             stringmathb$ = stringmathb$ + MID$(snotation$, 1, 2) + snexponent$
686.             IF LEN(snexponent$) + LEN(MID$(stringmathb$, 1, INSTR(UCASE$(stringmathb$), "E") - 1)) > limit&& + 1 THEN
687.                 stringmathb$ = "overflow"
688.             END IF
689.             exponentvalue&& = 0
690.         END IF
691.     ELSE
692.         IF INSTR(stringmathb$, ".") > 0 AND INSTR(stringmathb$, ".") <= limit&& THEN
693.             stringmathb$ = MID$(stringmathb$, 1, limit&& + 2)
694.             IF round_total% = -1 AND RIGHT$(stringmathb$, 1) > "4" THEN
695.                 GOSUB string_rounding_method
696.             ELSE
697.                 stringmathb$ = MID$(stringmathb$, 1, limit&& + 1)
698.                 IF show_rounding% THEN stringmathround$ = "r"
699.             END IF
700.         ELSE
701.             stringmathb$ = "overflow"
702.         END IF
703.     END IF
704.     RETURN
705. END IF
706. IF LEN(stringmathb$) > limit&& AND INSTR(stringmathb$, ".") = 0 OR LEN(stringmathb$) > limit&& + 1 AND INSTR(stringmathb$, ".") <> 0 THEN
707.     IF INSTR(stringmathb$, ".") = 0 THEN
708.         stringmathb$ = MID$(stringmathb$, 1, limit&& + 1)
709.     ELSE
710.         stringmathb$ = MID$(stringmathb$, 1, limit&& + 2)
711.     END IF
712.     GOSUB string_rounding_method
713.     IF LEN(stringmathb$) > limit&& + lrc_decimalpoint& THEN ' Ex: limit&& = 4 9999.9 1.e+4
714.         GOSUB numeric_to_scientific
715.     ELSE
716.         IF LEN(stringmathb$) > limit&& + lrc_decimalpoint& THEN stringmathb$ = "overflow"
717.     END IF
718. END IF
719. RETURN
720.  
721. replace_decimal:
722. IF addsubplace& THEN
723.     addsubx1$ = STRING$(addsubplace& - LEN(addsubx1$), "0") + addsubx1$
724.     addsubx1$ = MID$(addsubx1$, 1, LEN(addsubx1$) - addsubplace&) + "." + MID$(addsubx1$, LEN(addsubx1$) - addsubplace& + 1)
725.     DO UNTIL RIGHT$(addsubx1$, 1) <> "0" ' Remove trailing zeros in a decimal sum.
726.         addsubx1$ = MID$(addsubx1$, 1, LEN(addsubx1$) - 1)
727.         addsubplace& = addsubplace& - 1
728.     LOOP
729.     IF RIGHT$(addsubx1$, 1) = "." THEN addsubx1$ = MID$(addsubx1$, 1, LEN(addsubx1$) - 1) ' Number is now an integer.
730. END IF
731. RETURN
732.  
733. string_rounding_method:
734. IF INSTR(stringmathb$, ".") THEN lrc_decimalpoint& = 1 ELSE lrc_decimalpoint& = 0
735. IF MID$(stringmathb$, LEN(stringmathb$), 1) > "4" THEN
736.     FOR round_i& = LEN(stringmathb$) - 1 TO 1 STEP -1
737.         round_x$ = CHR$(ASC(MID$(stringmathb$, round_i&, 1)) + 1)
738.         IF round_x$ <> CHR$(47) THEN ' Decimal point + 1. Ignore.
739.             IF round_x$ = CHR$(58) THEN
740.                 MID$(stringmathb$, round_i&, 1) = "0": carry$ = "1"
741.             ELSE
742.                 MID$(stringmathb$, round_i&, 1) = round_x$: carry$ = "": EXIT FOR
743.             END IF
744.         END IF
745.     NEXT
746.     stringmathb$ = carry$ + MID$(stringmathb$, 1, LEN(stringmathb$) - 1): carry$ = ""
747.     IF show_rounding% THEN stringmathround$ = "R"
748. ELSE
749.     stringmathb$ = MID$(stringmathb$, 1, LEN(stringmathb$) - 1)
750.     IF show_rounding% THEN stringmathround$ = "r"
751. END IF
752.  
753. IF lrc_decimalpoint& THEN
754.     DO UNTIL RIGHT$(stringmathb$, 1) <> "0"
755.         stringmathb$ = MID$(stringmathb$, 1, LEN(stringmathb$) - 1)
756.     LOOP
757.     IF stringmathb$ = "" OR stringmathb$ = "." THEN stringmathb$ = "0": lrc_decimalpoint& = 0
758.     IF RIGHT$(stringmathb$, 1) = "." AND exponentvalue&& = 0 THEN
759.         stringmathb$ = MID$(stringmathb$, 1, LEN(stringmathb$) - 1): lrc_decimalpoint& = 0
760.     END IF
761. END IF
762. RETURN
763. END SUB

Pete

[Raven_Singularity]

Was the rounding oddity about "round to the nearest even number" functionality?

[Pete]

Do you mean in the screen shot I posted? If so, I was worried when my routine left the figure as all 9's. I thought the only way it wouldn't round up to 649146.5 is if the digit after that last 9 in 649146.49999999999 was an 8. So I checked it with a calculator, and it was an 8. That got rounded up as a nine, the last digit of the 17 digit limit I set for that operation. So it did round correctly. Also, I use a capital "R" at the end, to indicate it rounded up. A lowercase "r" would indicate it rounded down.

Pete

[Raven_Singularity]

I only know that BASIC in some form rounds up or down based on even whole numbers:

... -6, -4, -2, 0, 2, 4, 6 ...

So 1.5 and 2.5 would both round to 2.  I have never liked this style of rounding, I learned 0.5 rounds up, and -0.5 rounds up or down, depending on the type of rounding.  I don't like even-number rounding, because it creates uneven data sets:

0, 0, 2, 2, 4, 4 ...

Anyhow, probably not related, but one more odd way BASIC can round things internally.

[Pete]

I used round up for 5 and over, round down for 4 and under. That's a standard. The other way I think is called "Banker's Rounding." That's where if the rounding digit is 5, and there are no other non-zero digits trailing it, you look at the number immediately preceding the rounding number, and round up only if that preceding number is even.

I'm still on the fence if I would consider changing to that.

Pete

[Raven_Singularity]

I used round up for 5 and over, round down for 4 and under. That's a standard. The other way I think is called "Banker's Rounding." That's where if the rounding digit is 5, and there are no other non-zero digits trailing it, you look at the number immediately preceding the rounding number, and round up only if that preceding number is even.

I'm still on the fence if I would consider changing to that.

Pete

Banker's Rounding sounds like a more "fair" form of rounding.  0.5 is halfway, going up or down are both wrong, heh.  Dividing whether it goes up or down half the time is fair, but I didn't understand what you meant about the other digits causing the rounding.

[Pete]

Example: 2.315 and 2.325 round to hundredths.

In Banker's Rounding, we have both digits in the thousandth ending in a 5, so both numbers are eligible to be rounded.

Next we look at the digit in front of each 5.

2.315 (The digit in front of the 5 is a 1, and odd number.)

2.325 (The digit in front of the 5 is a 2, an even number.)

In Banker's Rounding, we round up the value of an odd number in front of the trailing "5" digit to an even number and we leave even numbers alone.

So, 2.315 gets changed to 2.325 and 2.125 stays as 2.325.

Now, to get to hundredths, we drop the 5 off of each, and end up with both being...

2.32

And I'm glad I did an example this time, because I just re-read my last post and I should have ended that last sentence with odd, not even, as in...

I used round up for 5 and over, round down for 4 and under. That's a standard. The other way I think is called "Banker's Rounding." That's where if the rounding digit is 5, and there are no other non-zero digits trailing it, you look at the number immediately preceding the rounding number, and round up only if that preceding number is odd.

So both round to 2.32—instead of 2.325 rounding up to 2.33—when rounded off to the nearest 100th. The rationale for the third rule is that approximately half of the time the number will be rounded up and the other half of the time it will be rounded down.

Sorry for messing that up in my previous post.

Pete

[Jack002]

I don't like rounding. I say if you want to round to the 3rd digit past the decimal then show me the 4th digit. I thought that rounding affects the accuracy of calculations negatively, but I can't seem to find people saying that.

My rounding pun
Farmer Brown had 290 cows but it was 300 once he rounded up

[jack]

maybe your pun should be "Farmer Brown thought he had 290 cows but it was 300 once he rounded up"

[Raven_Singularity]

"After losing his 290 cows, Farmer Brown later that day rounded up his 300 cows."

[SMcNeill]

You guys should quit picking on us farmers, when it comes to math.  We’re rather good at it.  To illustrate the point, let me tell you a tale my Grandpa told.

Back in the early 1900’s, everyone’s child was in a rush to head off to the city and get “educated” proper.  It turns out, Grandpa’s neighbor’s children all went off and headed to college.  While the oldest was getting his PHD, and the youngest was just starting, their father passed away.  All three children rushed home for the funeral and reading of the will.

In the will, their father divided up his herd of horses in the following manner.  The first born was supposed to get one half of the herd, the second child was supposed to get one third, while the youngest boy should’ve gotten one ninth.

Now, since their father had seventeen horses, they had no idea of what to do.  No mater how they proposed settling the issue, they just couldn’t make the numbers work to everyone’s satisfaction.  Luckily, my grandfather stopped by around that time to offer his condolences on their loss.  When presented with their quandary, he gave them his horse as a bereavement give.

With eighteen horses now, the oldest got nine, the second child got six, and the third child got two.  Taking the one that was left over as payment for services rendered, Grandfather left later that evening on the same horse he rode in on...

Who says farmers don’t know math?  ;D

[Jack002]

Well it looks like I drug this thread off topic. I'm denying all responsibility.

Rounding tho. Anyone else think its inaccurate? I think if you divide 1 by 3 and get 0.333333 report all your digits and don't hide or round anything. Calculators are now reporting in fractional mode and preserve value when its not a repeating integer.
We use numbers in base 10 (usually) to represent an idea. They are not the idea, they are the representation.