Post by: bplus on August 14, 2020, 05:05:05 pm
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]
- ' 2020-08-14 start with add 2 arbitrary long strings
- ' special or hard cases found while testing
- 'random testing
- 'pick two numbers
- addStr$ = add$(a$, b$)
- PRINT addStr$; " according to add function we are testing."
- PRINT qbCalc$; " according to QB64 math"
- PRINT "Next sum check in 10 secs, or press key, press escape to quit..."
- FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 8 so can take 8 digits at a time
- 'now taking 4 digits at a time From Steve I learned we can do more than 1 digit at a time
- result$ = new$ + result$
- 'debug
- 'PRINT m * 8, sa, sb, t$, co, result$
- 'INPUT "OK "; w$ 'OK
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- add$ = result$
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.
Post by: SMcNeill on August 14, 2020, 07:04:08 pm
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.
Post by: bplus on August 14, 2020, 09:19:13 pm
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]
OK will try 14 places but it's that 14-16 digits thing again, no, I feel safer with 12 places at a time.
Post by: bplus on August 14, 2020, 09:30:05 pm
Code: QB64: [Select]
- _TITLE "VAL Limit"
9 Digits is the limit? Is this a bug?
Post by: SMcNeill on August 14, 2020, 10:23:03 pm
Oh hell I had it right the first time, VAL() only gives us 9 digits when assigning to a variable!?!?Code: QB64: [Select]
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
Post by: bplus on August 14, 2020, 10:33:34 pm
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!
Post by: SMcNeill on August 14, 2020, 10:38:13 pm
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
Post by: bplus on August 14, 2020, 10:40:26 pm
Ok so 18 digits looks OK but 19 does not:
Post by: SMcNeill on August 14, 2020, 10:42:13 pm
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
Post by: bplus on August 14, 2020, 10:56:10 pm
But I don't know about the carry over 19th digit.
Post by: SMcNeill on August 14, 2020, 11:03:22 pm
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. :)
Post by: bplus on August 14, 2020, 11:59:40 pm
Quote
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]
- ' 2020-08-14 start with add 2 arbitrary long strings
- ' 2020-08-14 well it was 9PM when I started as per Steve switch to _UNSIGNED _INTEGER64
- ' special or hard cases found while testing
- DIM aa$
- PRINT " press any to for random testing that can be checked..."
- 'random testing
- 'pick two numbers
- addStr$ = add$(a$, b$)
- PRINT addStr$; " according to add function we are testing."
- PRINT qbCalc$; " according to QB64 math"
- PRINT "Next sum check in 10 secs, or press key, press escape to quit..."
- FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 8 so can take 8 digits at a time
- 'now taking 4 digits at a time From Steve I learned we can do more than 1 digit at a time
- result$ = new$ + result$
- 'debug
- 'DIM w$
- 'PRINT a$, m * 18, sa, sb, t$, co, result$
- 'INPUT "OK "; w$ 'OK
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- add$ = result$
Now back to that other distraction Subtraction, it's a little more tricky handling the borrowing.
Post by: SMcNeill on August 15, 2020, 12:14:08 am
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.)
Post by: bplus on August 15, 2020, 01:08:05 am
Here is subst$ function:
Code: QB64: [Select]
- ' 2020-08-14 start with add 2 arbitrary long strings
- ' 2020-08-14 add$ posted 5 PM or so
- ' 2020-08-14 opt explicit, start subtr$ function
- ' 2020-08-15 1 AM subst$ function looking good!
- ' special or hard cases found while testing
- PRINT "press any for Random testing against QB64 math calculations..."
- 'random testing
- 'pick two numbers
- subtrStr$ = subtr$(a$, b$)
- PRINT subtrStr$; " according to subtr$ function we are testing."
- PRINT qbCalc$; " according to QB64 math"
- PRINT "Next sum check in 10 secs, or press key, press escape to quit..."
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- ' which is bigger?
- sign$ = ""
- sign$ = "-"
- sign$ = ""
- sign$ = "-"
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- 'debug
- 'PRINT VB, tenE18, tenE18 - vs + VB, " t$ = "; t$
- ''borrow 1 = rewrite string
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- subtr$ = sign$ + result$
- FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- 'debug
- 'DIM w$
- 'PRINT a$, m * 18, sa, sb, t$, co, result$
- 'INPUT "OK "; w$ 'OK
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- add$ = result$
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.
Post by: bplus on August 15, 2020, 03:43:25 pm
Code: QB64: [Select]
- ' 2020-08-14 start with add 2 arbitrary long strings
- ' 2020-08-14 add$ posted 5 PM or so
- ' 2020-08-14 opt explicit, start subtr$ function
- ' 2020-08-15 1 AM subst$ function looking good!
- ' 2020-08-15 fix some code from previous subs then attempt mult$ sub
- _DELAY .25
- ''test that VAL can do 9 * 18 nines
- 'DIM a AS _UNSIGNED _INTEGER64, b AS _UNSIGNED _INTEGER64, c AS _UNSIGNED _INTEGER64
- 'b = 9
- 'a = VAL(STRING$(18, "9"))
- 'c = a * b
- 'PRINT c 'OK
- ' special or hard cases found while testing
- DIM test$
- 'random testing
- 'pick two numbers
- multStr$ = mult$(a$, b$)
- PRINT multStr$; " according to mult$ function we are testing."
- PRINT qbCalc$; " according to QB64 math"
- PRINT "Next sum check in 10 secs, or press key, press escape to quit..."
- SLEEP 10
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- NEXT g
- accum$ = build$
- NEXT dp
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- mult$ = accum$
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- ' which is bigger?
- sign$ = ""
- sign$ = "-"
- sign$ = ""
- sign$ = "-"
- 'now taking 18 digits at a time From Steve I learned we can do 18
- 'debug
- 'PRINT VB, tenE18, tenE18 - vs + VB, " t$ = "; t$
- ''borrow 1 = rewrite string
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- subtr$ = sign$ + result$
- FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- 'debug
- 'DIM w$
- 'PRINT a$, m * 18, sa, sb, t$, co, result$
- 'INPUT "OK "; w$ 'OK
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- add$ = result$
@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$)
Post by: bplus on August 15, 2020, 05:12:46 pm
If the 500th is correct then it is pretty good assumption that all that went before it is correct.
1135 digits all good! And done in a sneeze.
Code: QB64: [Select]
- ' 2020-08-14 start with add 2 arbitrary long strings
- ' 2020-08-14 add$ posted 5 PM or so
- ' 2020-08-14 opt explicit, start subtr$ function
- ' 2020-08-15 1 AM subst$ function looking good!
- ' 2020-08-15 fix some code from previous subs then attempt mult$ sub
- ' 2020-08-15 Factorials! a wonderful test for String Math mult$
- ' 2020-08-15 WOW! 500 factorials in an instant and it's matching 500!
- ' at https://www.calculatorsoup.com/calculators/discretemathematics/factorials.php
- _DELAY .25
- FactorialSetup
- 'find the highest factorial we have so far
- top = top + 1
- 'finish later
- SUB FactorialSetup
- fac$ = "1"
- PRINT i, fac$
- CLOSE #1
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- NEXT g
- accum$ = build$
- NEXT dp
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- mult$ = accum$
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- ' which is bigger?
- sign$ = ""
- sign$ = "-"
- sign$ = ""
- sign$ = "-"
- 'now taking 18 digits at a time From Steve I learned we can do 18
- 'debug
- 'PRINT VB, tenE18, tenE18 - vs + VB, " t$ = "; t$
- ''borrow 1 = rewrite string
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- subtr$ = sign$ + result$
- FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- 'debug
- 'DIM w$
- 'PRINT a$, m * 18, sa, sb, t$, co, result$
- 'INPUT "OK "; w$ 'OK
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- add$ = result$
[ This attachment cannot be displayed inline in 'Print Page' view ]
Post by: bplus on August 16, 2020, 02:48:15 pm
Update, failed:
Code: QB64: [Select]
Fix one thing and another goes bad:
Code: QB64: [Select]
- ' 2020-08-14 start with add 2 arbitrary long strings
- ' 2020-08-14 add$ posted 5 PM or so
- ' 2020-08-14 opt explicit, start subtr$ function
- ' 2020-08-15 1 AM subst$ function looking good!
- ' 2020-08-16 problem found with string compare and QB64 fails compare with longer strings
- 'RANDOMIZE TIMER 'now that it's seems to be running silent
- _DELAY .25
- ' special or hard cases found while testing
- PRINT "press any for Random testing against QB64 math calculations..."
- 'random testing
- 'pick two numbers
- subtrStr$ = subtr$(a$, b$)
- PRINT subtrStr$; " according to subtr$ function we are testing."
- PRINT qbCalc$; " according to QB64 math"
- PRINT "Next sum check in 10 secs, or press key, press escape to quit..."
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- ' which is bigger?
- sign$ = ""
- sign$ = "-"
- 'IF ls > lm THEN
- ' sign$ = ""
- ' m = INT(ls / 18) + 1
- ' LG$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
- ' sm$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
- 'ELSEIF ls < lm THEN
- ' sign$ = "-"
- ' m = INT(lm / 18) + 1
- ' LG$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
- ' sm$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
- 'ELSEIF ls = lm THEN
- ' FOR i = 1 TO LEN(sum$)
- ' IF VAL(MID$(sum$, i, 1)) > VAL(MID$(minus$, i, 1)) THEN
- ' sign$ = ""
- ' m = INT(ls / 8) + 1
- ' LG$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
- ' sm$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
- ' EXIT FOR
- ' ELSEIF VAL(MID$(sum$, i, 1)) < VAL(MID$(minus$, i, 1)) THEN
- ' sign$ = "-"
- ' m = INT(lm / 18) + 1
- ' LG$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
- ' sm$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
- ' EXIT FOR
- ' END IF
- ' NEXT
- 'END IF
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- 'debug
- 'PRINT VB, tenE18, tenE18 - vs + VB, " t$ = "; t$
- ''borrow 1 = rewrite string
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- subtr$ = sign$ + result$
- FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- 'debug
- 'DIM w$
- 'PRINT a$, m * 18, sa, sb, t$, co, result$
- 'INPUT "OK "; w$ 'OK
- 'strip 0
- i = 1: find = 0
- i = i + 1: find = 1
- add$ = result$
OK guess I have to roll my own.
Post by: SMcNeill on August 16, 2020, 04:11:00 pm
First, a function to deal with doubles. FUNCTION DWD (text$) searches text$ and converts double symbols to reverse symbols. ++ becomes +, -- becomes +, -+ becomes -, +- becomes -.
For example, 3 + -2 (Three plus negative two) becomes 3 - 2.
Then in your routines, check to make certain that your two values have the same sign.
-3 -4 -- this is addition, as the two values are both negative. Just kick it from your subtraction routine to your addition routine and return the result from there.
-3 + 4 -- this is subtraction, even though the symbol between them in +. Once again, just kick it to the appropriate function and return the result from there.
And a routine to convert scientific notion to string is nice as well, so you can add 3E+20 to 1234567899012345678987654321.
If you look in QB64.BAS, you'll find most of these little helper routines already worked up and in use inside there, as they're part of the CONST calculations we do. (Also in my math evaluator, which works with strings as well.)
Post by: bplus on August 16, 2020, 04:28:09 pm
Yeah I am taking care of mom too (89), she can't remember anything new and plagued with aches and pains but old memories are hanging in there, she does crossword puzzles every day.
I am saving signs for later as well as decimal point handling. My first goal is the 4 main arithmetic subs going for arbitrary long positive integers. I save the best for last Division, then signs, then decimals...
I know I am reinventing the wheel but you learn inside stuff with DIY. Then if you have a bug or want to handle decimals different you know (maybe if you remember) how to get what you want without having to learn the whole thing anyway using someone else approach. Of course, someone else approach could be much more clever but how do you know if you didn't try it yourself?
I am working on 2 helper functions now and rewriting add$, subtr$, mult$ with lines of code savings! If things work out ;-))
Post by: bplus on August 16, 2020, 09:57:24 pm
I am intending to use multiplicative inverses, ie for n / d, use n * 1/d.
Post by: bplus on August 17, 2020, 01:25:10 am
Code: QB64: [Select]
- ' I always want to try doing division by multipling the numerator
- ' by the multiplicative inverse of denominator.
- ' n/d = n * 1/d so how bout a function that does 1/n
- ' Then divide$() is pretty easy with mult$
- _DELAY .25
- 'special cases or hard cases
- PRINT " OK try some Divisions "
- 'random testing
- 'pick two numbers
- divStr$ = divide$(num$, den$)
- PRINT divStr$; " according to mult$ function we are testing."
- PRINT qbCalc$; " according to QB64 math"
- ' <<<<<<<<<< stop when find an discrepency
- PRINT "Next divide$() check in 10 secs, or press key, press escape to quit..."
- SLEEP 10
- di$ = nInverse$(d$, 100)
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- NEXT g
- accum$ = build$
- NEXT dp
- mult$ = accum$
- ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$)
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- ELSE 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- 'debug
- 'PRINT VB, tenE18, tenE18 - vs + VB, " t$ = "; t$
- ''borrow 1 = rewrite string
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- 'debug
- 'DIM w$
- 'PRINT a$, m * 18, sa, sb, t$, co, result$
- 'INPUT "OK "; w$ 'OK
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$)
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- DIM t$
- t$ = TrimLead0$(s$)
- trim0$ = TrimTail0$(t$)
Post by: STxAxTIC on August 17, 2020, 03:16:17 am
Quote
It turns out that the first hundred (or so) Fibonacci Numbers can be produced by inverting the integer 999999999999999999999998999999999999999999999999 (bonus points for noticing that one of the digits is not a 9).
Code: [Select]
print_
largediv(
1.(for(<i,1,2495,1>,{0})),
999999999999999999999998999999999999999999999999
)
Code: [Select]
+0.000000000000000000000000000000000000000000000001000000000000000000000001000000000000000000000002000000000000000000000003000000000000000000000005000000000000000000000008000000000000000000000013000000000000000000000021000000000000000000000034000000000000000000000055000000000000000000000089000000000000000000000144000000000000000000000233000000000000000000000377000000000000000000000610000000000000000000000987000000000000000000001597000000000000000000002584000000000000000000004181000000000000000000006765000000000000000000010946000000000000000000017711000000000000000000028657000000000000000000046368000000000000000000075025000000000000000000121393000000000000000000196418000000000000000000317811000000000000000000514229000000000000000000832040000000000000000001346269000000000000000002178309000000000000000003524578000000000000000005702887000000000000000009227465000000000000000014930352000000000000000024157817000000000000000039088169000000000000000063245986000000000000000102334155000000000000000165580141000000000000000267914296000000000000000433494437000000000000000701408733000000000000001134903170000000000000001836311903000000000000002971215073000000000000004807526976000000000000007778742049000000000000012586269025000000000000020365011074000000000000032951280099000000000000053316291173000000000000086267571272000000000000139583862445000000000000225851433717000000000000365435296162000000000000591286729879000000000000956722026041000000000001548008755920000000000002504730781961000000000004052739537881000000000006557470319842000000000010610209857723000000000017167680177565000000000027777890035288000000000044945570212853000000000072723460248141000000000117669030460994000000000190392490709135000000000308061521170129000000000498454011879264000000000806515533049393000000001304969544928657000000002111485077978050000000003416454622906707000000005527939700884757000000008944394323791464000000014472334024676221000000023416728348467685000000037889062373143906000000061305790721611591000000099194853094755497000000160500643816367088000000259695496911122585000000420196140727489673000000679891637638612258000001100087778366101931000001779979416004714189000002880067194370816120000004660046610375530309000007540113804746346429000012200160415121876738000019740274219868223167000031940434634990099905000051680708854858323072000083621143489848422977000135301852344706746049000218922995834555169026000354224848179261915075000573147844013817084101000927372692193078999176001500520536206896083277002427893228399975082453003928413764606871165730006356306993006846248183010284720757613717413913
Post by: bplus on August 17, 2020, 09:20:09 am
The first order of business today was fixing the nInverse function with a decimal point because I need to return 1 (without decimal) when n = 1
2nd thing is rounding when I get a repeating stream of 9's for divide, usually it means it should be infinitesimally small nudge more.
Post by: bplus on August 17, 2020, 11:56:07 am
Code: QB64: [Select]
- ' 2020-08-16 picking up from Sting Math add$(), subtr$(), mult$() onto divide$()
- ' I always wanted to try doing division by multipling the numerator
- ' by the multiplicative inverse of denominator.
- ' n/d = n * 1/d so how bout a function that does 1/n.
- ' Then divide$() is pretty easy with mult$ Yes works but need more decimal work.
- ' 2020-08-17 redo all this with a decimal point for nInverse just start outstr with "." instead ""
- ' Now somethings off with divide$() first is 1 / 500 should be .002 returning .2, debug."
- ' Much better than post of last night
- ' showDP rounds up to DP (Decimal Places IF there are more decimals past DP)
- _DELAY .25
- 'special cases or hard cases
- PRINT ".142857 and repeat forever ? for 1/7"
- PRINT "1/ (9 nines) should b"
- PRINT ".000000001 repeated forever ?"
- PRINT "1/ (20 ones) should be 19 zeros nine repeated forever ?"
- PRINT ".00000000000000000009 repeat forever ?"
- PRINT ".0009765625 ?"
- PRINT ".0013947 repeat forever ?"
- PRINT " OK try some Divisions "
- PRINT "test showDP fix 9's to 4 places?"
- 'random testing
- 'pick two numbers
- divStr$ = divide$(num$, den$)
- PRINT qbCalc$; " according to QB64 math"
- ' <<<<<<<<<< stop when find an discrepency
- PRINT "Next divide$() check in 10 secs, or press key, press escape to quit..."
- SLEEP 10
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- NEXT g
- accum$ = build$
- NEXT dp
- mult$ = accum$
- ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$)
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- ELSE 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- 'debug
- 'PRINT VB, tenE18, tenE18 - vs + VB, " t$ = "; t$
- ''borrow 1 = rewrite string
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- 'debug
- 'DIM w$
- 'PRINT a$, m * 18, sa, sb, t$, co, result$
- 'INPUT "OK "; w$ 'OK
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$)
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- DIM t$
- t$ = TrimLead0$(s$)
- trim0$ = TrimTail0$(t$)
- ' for displaying truncated numbers say to 60 digits
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
Milestone #1 the 4 Basic Arithmetic operations, plus display control of number (wo changing original number string).
Now for some fun with STx quiz ;-))
Post by: bplus on August 17, 2020, 12:44:30 pm
(note: _UNSIGNED _INTEGER64 couldn't go the distance.)
Code: QB64: [Select]
- ' 2020-08-16 picking up from Sting Math add$(), subtr$(), mult$() onto divide$()
- ' I always wanted to try doing division by multipling the numerator
- ' by the multiplicative inverse of denominator.
- ' n/d = n * 1/d so how bout a function that does 1/n.
- ' Then divide$() is pretty easy with mult$ Yes works but need more decimal work.
- ' 2020-08-17 redo all this with a decimal point for nInverse just start outstr with "." instead ""
- ' Now somethings off with divide$() first is 1 / 500 should be .002 returning .2, debug."
- ' Much better than post of last night
- ' showDP rounds up to DP (Decimal Places IF there are more decimals past DP)
- ' 2020-08-17 from Multplicative Inverse: nInverse$ and divide$
- ' STx Fibonacci from
- ' ref: https://www.qb64.org/forum/index.php?topic=2921.msg121845#msg121845
- _DELAY .25
- 'special cases or hard cases
- DIM STxFib$
- STxFib$ = nInverse$("999999999999999999999998999999999999999999999999", 2495) '2445 DP? is what he has
- PRINT STxFib$
- 'OK starts good let's parse it
- i = 3
- fibi(1) = "1"
- fibi(2) = "1"
- find = 0
- fibi(i) = trim0$(add$(fibi(i - 2), fibi(i - 1)))
- i = i + 1
- PRINT "Failed to find next Fibonacci number"; i
- dont = -1
- PRINT "Press any to continue..."
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- NEXT g
- accum$ = build$
- NEXT dp
- mult$ = accum$
- ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$)
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- ELSE 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- 'debug
- 'PRINT VB, tenE18, tenE18 - vs + VB, " t$ = "; t$
- ''borrow 1 = rewrite string
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- 'debug
- 'DIM w$
- 'PRINT a$, m * 18, sa, sb, t$, co, result$
- 'INPUT "OK "; w$ 'OK
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$)
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- DIM t$
- t$ = TrimLead0$(s$)
- trim0$ = TrimTail0$(t$)
- ' for displaying truncated numbers say to 60 digits
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
Post by: bplus on August 18, 2020, 03:40:27 pm
Code: QB64: [Select]
- ' 2020-08-16 picking up from String Math add$(), subtr$(), mult$() onto divide$()
- ' I always wanted to try doing division by multipling the numerator
- ' by the multiplicative inverse of denominator.
- ' n/d = n * 1/d so how bout a function that does 1/n.
- ' Then divide$() is pretty easy with mult$ Yes works but need more decimal work.
- ' 2020-08-17 redo all this with a decimal point for nInverse just start outstr with "." instead ""
- ' Now somethings off with divide$() first is 1 / 500 should be .002 returning .2, debug."
- ' Much better than post of last night
- ' showDP rounds up to DP (Decimal Places IF there are more decimals past DP)
- ' 2020-08-17 Math regulator mr$(a$, ops$, b$) ' manages before and after calls to 4 basic arith operations
- ' note: 265 lines with just the set of functions so far
- ' 2020-08-18 last night subtr and signs confused hell out of me but I think I have all code I need for +!
- ' OK add and subtr seem to be working with signs and decimals but ugly code, can we combine lines?
- ' OH yeah, traded 12 redundant lines for 2! and a bunch of debug and other 389 lines to 354
- ' OK setup for * and /, mr$ finished adding 77 lines of code
- ' OK everything is simple after divide$() and substraction with signs and decimals ;-))
- _DELAY .25
- ' debug tests
- 'PRINT "2105 ? "
- 'PRINT mr$("5", "+", "2100") ' OK
- 'PRINT "-10039.0965 ? "
- 'PRINT mr$("6.1035", "+", "-10045.2") ' OK
- 'PRINT "-801.99968 ?"
- 'PRINT mr$("-802", "+", ".00032")
- 'PRINT "-.0003500009 ?"
- 'PRINT mr$("-.00035", "+", "-.0000000009")
- 'PRINT "-5 ?"
- 'PRINT mr$("-10", "-", "-5")
- 'PRINT "-15 ?"
- 'PRINT mr$("-10", "-", "5") 'X fixed
- 'PRINT "15 ?"
- 'PRINT mr$("10", "-", "-5")
- 'PRINT "5 ?"
- 'PRINT mr$("10", "-", "5")
- 'PRINT "4.99 ?"
- 'PRINT mr$("-.010", "-", "-5")
- 'PRINT "-5.01 ?"
- 'PRINT mr$("-.010", "-", "5") 'X fixed
- 'PRINT "5.01 ?"
- 'PRINT mr$(".010", "-", "-5")
- 'PRINT "-4.99 ?"
- 'PRINT mr$(".010", "-", "5")
- 'PRINT .00207 * 10000; "?"
- 'PRINT mr$(".00207", " * ", "10000") 'OK
- 'PRINT 2468.02468 / .02; "?"
- 'PRINT mr$("2468.02468", "/", ".02") 'OK
- 'PRINT -.333333333333333333 * -3.00000000000; "?"
- 'PRINT mr$("-.333333333333333333", "*", "-3.00000000000") 'OK
- 'PRINT -1.0000001 / .07; "?"
- 'PRINT mr$("-1.0000001", "/", ".07") 'OK
- 'PRINT 90.9 / -30; "?"
- 'PRINT mr$("90.9", "/", "-30") 'OK
- 'random testing for correct signs, decimal places and values
- 'pick two numbers
- ma$ = "-": ma = -1
- ma$ = "": ma = 1
- mb$ = "-": mb = -1
- mb$ = "": mb = 1
- mrStr$ = mr$(a$, op$, b$)
- PRINT mrStr$; " according to mr$ function we are testing."
- PRINT qbCalc$; " according to QB64 math"
- PRINT "Next subtr$ check in 10 secs, or press key, press escape to quit..."
- 'strip signs and decimals
- aSgn$ = "": ca$ = ca$
- adp = 0
- bSgn$ = "": cb$ = cb$
- bdp = 0
- 'even up the right sides of decimals if any
- dp = adp + bdp
- 'now according to signs and op$ call add$ or subtr$
- postOp$ = aSgn$ + add$(ca$, cb$)
- ELSE 'have a case of subtraction
- bSgn$ = ""
- postOp$ = subtr$(cb$, ca$)
- ELSE 'aSgn = ""
- postOp$ = add$(ca$, cb$)
- ELSE 'bSgn$ =""
- bSgn$ = "-"
- postOp$ = aSgn$ + add$(ca$, cb$)
- postOp$ = subtr$(ca$, cb$)
- 'put dp back
- mr$ = trim0$(postOp$)
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- NEXT g
- accum$ = build$
- NEXT dp
- mult$ = accum$
- ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$)
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- ELSE 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$)
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- DIM cs$, si$
- cs$ = s$
- cs$ = TrimLead0$(cs$)
- cs$ = TrimTail0$(cs$)
- ' for displaying truncated numbers say to 60 digits
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
Update 2021-06-03: Nope! Sorry the divide$ function was buggy. Had to pull the link to this code from Library.
Post by: bplus on June 03, 2021, 09:24:02 am
Main code is testing a 100 digit precision Square Root Code and Divide$ has the "fixed"? String Math patch
Code: QB64: [Select]
- _Delay .25
- 'remember everything is strings
- Input "Enter a number to find it's square root "; n$
- guess$ = mr$(n$, "/", "2") ' for n$ = 2
- other$ = n$
- loopCnt = 0
- loopCnt = loopCnt + 1
- Print loopCnt; " guess: "; guess$
- 'Input "Continue press enter, any other to quit "; cont$
- 'If cont$ = "" Then
- lastGuess$ = guess$
- 'Print "guess$ "; guess$
- 'Print "other$ "; other$
- sum$ = mr$(guess$, "+", other$)
- 'Print "sum$ "; sum$
- 'Print "Call divide for guess$, sum$ / 2"
- guess$ = mr$(sum$, "/", "2")
- 'Print "Call n$ divide new guess$ for other$, n$ / guess$"
- other$ = mr$(n$, "/", guess$)
- 'Else
- ' Exit Do
- 'End If
- 'strip signs and decimals
- aSgn$ = "": ca$ = ca$
- adp = 0
- bSgn$ = "": cb$ = cb$
- bdp = 0
- 'even up the right sides of decimals if any
- dp = adp + bdp
- 'now according to signs and op$ call add$ or subtr$
- postOp$ = aSgn$ + add$(ca$, cb$)
- Else 'have a case of subtraction
- bSgn$ = ""
- postOp$ = subtr$(cb$, ca$)
- Else 'aSgn = ""
- postOp$ = add$(ca$, cb$)
- Else 'bSgn$ =""
- bSgn$ = "-"
- postOp$ = aSgn$ + add$(ca$, cb$)
- postOp$ = subtr$(ca$, cb$)
- 'put dp back
- mr$ = trim0$(postOp$)
- 'Print "divide$ got n$ = "; n$; " and d$ = "; d$
- ' aha! found a bug when d$ gets really huge 100 is no where near enough!!!!
- ' 2021-06-03 fix by adding 100 to len(d$), plus have to go a little past 100 for 100 digit precision
- ' need to go past 100 for 100 precise digits (not decimal places)
- 'Print "divide$ inverse of d$ = di$ = "; di$
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- Next g
- accum$ = build$
- Next dp
- mult$ = accum$
- ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$)
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- Else 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- Function add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$)
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- Dim cs$, si$
- cs$ = s$
- cs$ = TrimLead0$(cs$)
- cs$ = TrimTail0$(cs$)
- ' for displaying truncated numbers say to 60 digits
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
Going back to oh to replace the Divide$ function there.
Here is a list of compares between Square Root from above code and an Internet Calculator (that rounds it's last digit in decimal place, whereas this code cuts off at that digit # not decimal place.)
Code: [Select]
First show code clipboard result then show Internet Calculator result
from https://www.mathsisfun.com/calculator-precision.html
Square root 2 first from String Math then Internet Result
1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641572
1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727
Square root of 3...
1.732050807568877293527446341505872366942805253810380628055806979451933016908800037081146186757248575
1.7320508075688772935274463415058723669428052538103806280558069794519330169088000370811461867572485757
Square root of 4...
gets stuck in infinite loop 1.999999999999999999999999....
2 of course!
OK compare guess to last guess and if they match out to 105 digits then 100 digits must be accurate
1.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
2 of course!
SR 5
2.236067977499789696409173668731276235440618359611525724270897245410520925637804899414414408378782274
2.23606797749978969640917366873127623544061835961152572427089724541052092563780489941441440837878227497
SR 6
2.449489742783178098197284074705891391965947480656670128432692567250960377457315026539859433104640234
2.44948974278317809819728407470589139196594748065667012843269256725096037745731502653985943310464023482
SR 7
2.645751311064590590501615753639260425710259183082450180368334459201068823230283627760392886474543610
2.64575131106459059050161575363926042571025918308245018036833445920106882323028362776039288647454361062
Post by: George McGinn on June 03, 2021, 03:15:45 pm
I use the The Newton-Raphson Iteration method to calculate the square root as well as the n'th roots (see link: https://secure.math.ubc.ca/~anstee/math104/104newtonmethod.pdf (https://secure.math.ubc.ca/~anstee/math104/104newtonmethod.pdf)).
It is more accurate than your "best answer."
Here is the code to execute this method:
Code: QB64: [Select]
- '*** square root function
- x = A / 2: precision = 0.000001: max_iterations = 30
- dx = (x - A / x) / 2: x = x - dx
- NEXT i
Attempting to extend String Math into Square Roots, I discovered a huge bug with Divide$ Function, it's all commented in code below. I think I have it patched but maybe not. This is tricky without Boolean Compares for String Math.
Main code is testing a 100 digit precision Square Root Code and Divide$ has the "fixed"? String Math patchCode: QB64: [Select]
Going back to oh to replace the Divide$ function there.
Here is a list of compares between Square Root from above code and an Internet Calculator (that rounds it's last digit in decimal place, whereas this code cuts off at that digit # not decimal place.)Code: [Select]First show code clipboard result then show Internet Calculator result
from https://www.mathsisfun.com/calculator-precision.html
Square root 2 first from String Math then Internet Result
1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641572
1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727
Square root of 3...
1.732050807568877293527446341505872366942805253810380628055806979451933016908800037081146186757248575
1.7320508075688772935274463415058723669428052538103806280558069794519330169088000370811461867572485757
Square root of 4...
gets stuck in infinite loop 1.999999999999999999999999....
2 of course!
OK compare guess to last guess and if they match out to 105 digits then 100 digits must be accurate
1.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
2 of course!
SR 5
2.236067977499789696409173668731276235440618359611525724270897245410520925637804899414414408378782274
2.23606797749978969640917366873127623544061835961152572427089724541052092563780489941441440837878227497
SR 6
2.449489742783178098197284074705891391965947480656670128432692567250960377457315026539859433104640234
2.44948974278317809819728407470589139196594748065667012843269256725096037745731502653985943310464023482
SR 7
2.645751311064590590501615753639260425710259183082450180368334459201068823230283627760392886474543610
2.64575131106459059050161575363926042571025918308245018036833445920106882323028362776039288647454361062
Post by: jack on June 03, 2021, 03:55:53 pm
here's some interesting code that if you manage to translate to QB64 might be useful as a first approximation for the Newton-Raphson Method
this is FreeBbasic code but the code is very short and the algorithm is explained in comments
Code: [Select]
'=======================================================================
' approximate a ^ b
Function approx_power( Byval a As Double, Byval b As Double ) As Double
Dim As Long Ptr fp = 1 + Cptr( Long Ptr, @a )
Dim As Long tmp = ( *fp - 1072632447 ) * b
*fp = tmp + 1072632447
Return a
End Function
'=======================================================================
' How and Why It Works.
' To accurately compute y = a^b; for non-integer b; with a > 0;
' take the log(a), multiply it by b, then look up the antilog, which is
' the Exp() function, to give; y = Exp( b * Log( a ) )
' For a computer using base 2 it is convenient to use; y = 2^( b * Log2(a) )
' The IEEE double precision floating point format has an 11 bit, base two,
' integer exponent. That will become the integer part of the log2(x) function.
' It is simple to extract the exponent, multiply it by b, then return it to
' the exponent, but that would be a clunky approximation because the exponent
' is an integer count of powers of two with poor resolution.
' So that the multiply will change the result for small changes of a or power b,
' the leading 20 mantissa bits are included as a false fractional extension to
' the logarithmic exponent. That is the source of error in this approximation.
' Note that the implicit 1 msb is missing from the mantissa.
' The exponent offset bias of 1022 must be removed by subtraction before the
' multiplication. In the same operation an amount can be deducted from the
' mantissa to significantly reduce the approximation error. The approximation
' is computed from only the top 32 bits of the 64 bit double precision format.
' &bSeeeeeeeeeeeffffffffffffffffffff Sign bit, exponent and fraction format
' &b00111111111000000000000000000000 1071644672 = 1022 * 2^20, shifted bias
' &b00000000000011110001001001111111 987775 = fudge amount
' &b00111111111011110001001001111111 1072632447 = sum is the magic number
'=======================================================================
dim as double x, y, z
Print approx_power( 123.456789, .5 ), sqr(123.456789)
here's the QB64 versionCode: QB64: [Select]
- a = x#
- tmp = (tmp - 1072632447) * y#
- tmp = tmp + 1072632447
- approx_power = a
Post by: bplus on June 03, 2021, 04:14:07 pm
OK I see you both like Newton-Raphson, I've see it like 50 years ago in math class so must be better. I will try and work it that way then.
In meantime I've chosen other$ to return with function because sometimes it nails the answer precisely without a bunch of .99999999's on end, not always but less than guess$. I am also handling negative numbers by tacking on an *i to the end of the number returned, better than error message, maybe.
Code: QB64: [Select]
- ' divide$ found fix? 2021-06-03 comment in that function
- ' 2021-06-03 update with new sqrRoot$ Function
- _Delay .25
- Dim n$, result$
- 'remember everything is strings
- Input "Enter a number to find it's square root "; n$
- result$ = sqrRoot$(n$)
- Print result$
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2")
- other$ = n$
- lastGuess$ = guess$
- sum$ = mr$(guess$, "+", other$)
- guess$ = mr$(sum$, "/", "2")
- other$ = mr$(n$, "/", guess$)
- 'strip signs and decimals
- aSgn$ = "": ca$ = ca$
- adp = 0
- bSgn$ = "": cb$ = cb$
- bdp = 0
- 'even up the right sides of decimals if any
- dp = adp + bdp
- 'now according to signs and op$ call add$ or subtr$
- postOp$ = aSgn$ + add$(ca$, cb$)
- Else 'have a case of subtraction
- bSgn$ = ""
- postOp$ = subtr$(cb$, ca$)
- Else 'aSgn = ""
- postOp$ = add$(ca$, cb$)
- Else 'bSgn$ =""
- bSgn$ = "-"
- postOp$ = aSgn$ + add$(ca$, cb$)
- postOp$ = subtr$(ca$, cb$)
- 'put dp back
- mr$ = trim0$(postOp$)
- ' aha! found a bug when d$ gets really huge 100 is no where near enough!!!!
- ' 2021-06-03 fix by adding 100 to len(d$), plus have to go a little past 100 for 100 digit precision
- ' need to go past 100 for 100 precise digits (not decimal places)
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- Next g
- accum$ = build$
- Next dp
- mult$ = accum$
- ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$)
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- Else 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- Function add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$)
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- Dim cs$, si$
- cs$ = s$
- cs$ = TrimLead0$(cs$)
- cs$ = TrimTail0$(cs$)
- ' for displaying truncated numbers say to 60 digits
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
I was all set to make this the new Best Answer but I will investigate adapting Newton-Raphson, a better start from jack and a better method from george.
Post by: Pete on June 03, 2021, 06:20:31 pm
Pete
Post by: jack on June 03, 2021, 06:32:09 pm
Code: QB64: [Select]
- x# = 1D100: y# = 7
- 'take x to an integer power
- y = x
- z = 1#
- n = n \ 2
- y = y * y
- n = n - 1
- z = y * z
- ipow = 1# / z
- ipow = z
- a = x#: b = 1# / y#
- tmp = (tmp - 1072632447) * b
- tmp = tmp + 1072632447
- a = a - (ipow(a, y#) - x#) / (y# * ipow(a, y# - 1))
- a = a - (ipow(a, y#) - x#) / (y# * ipow(a, y# - 1))
- a = a - (ipow(a, y#) - x#) / (y# * ipow(a, y# - 1))
- a = a - (ipow(a, y#) - x#) / (y# * ipow(a, y# - 1))
- approx_power = a
Post by: bplus on June 03, 2021, 08:43:39 pm
Code: QB64: [Select]
- ' divide$ found fix? 2021-06-03 comment in that function
- ' 2021-06-03 update with new sqrRoot$ Function
- _Delay .25
- Dim n$, result$
- 'remember everything is strings
- Input "Enter a number to find it's square root "; n$
- result$ = sqrRoot$(n$)
- Print result$
- _Delay 2
- result$ = SRbyNR$(n$)
- Print result$
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2")
- other$ = n$
- loopcnt = loopcnt + 1
- Print "loop cnt"; loopcnt
- sqrRoot$ = Mid$(other$, 1, 101) + imaginary$ ' try other factor for guess$ sometimes it nails answer without all digits
- lastGuess$ = guess$
- sum$ = mr$(guess$, "+", other$)
- guess$ = mr$(sum$, "/", "2")
- other$ = mr$(n$, "/", guess$)
- Function SRbyNR$ (nmbr$) ' square root by Newton - Ralphson method my interpretation of GeorgeMcGinn
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2") ' get this going first and then try better starting guess later
- loopcnt = loopcnt + 1
- Print "loop cnt"; loopcnt
- 'dx = (x - A / x) / 2: x = x - dx ' Thanks George
- lastGuess$ = guess$
- dx$ = mr$(mr$(guess$, "-", mr$(n$, "/", guess$)), "/", "2")
- guess$ = mr$(guess$, "-", dx$)
- other$ = mr$(n$, "/", guess$) ' try other factor for guess$ sometimes it nails answer without all digits
- 'strip signs and decimals
- aSgn$ = "": ca$ = ca$
- adp = 0
- bSgn$ = "": cb$ = cb$
- bdp = 0
- 'even up the right sides of decimals if any
- dp = adp + bdp
- 'now according to signs and op$ call add$ or subtr$
- postOp$ = aSgn$ + add$(ca$, cb$)
- Else 'have a case of subtraction
- bSgn$ = ""
- postOp$ = subtr$(cb$, ca$)
- Else 'aSgn = ""
- postOp$ = add$(ca$, cb$)
- Else 'bSgn$ =""
- bSgn$ = "-"
- postOp$ = aSgn$ + add$(ca$, cb$)
- postOp$ = subtr$(ca$, cb$)
- 'put dp back
- mr$ = trim0$(postOp$)
- ' aha! found a bug when d$ gets really huge 100 is no where near enough!!!!
- ' 2021-06-03 fix by adding 100 to len(d$), plus have to go a little past 100 for 100 digit precision
- ' need to go past 100 for 100 precise digits (not decimal places)
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- Next g
- accum$ = build$
- Next dp
- mult$ = accum$
- ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$)
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- Else 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- Function add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$)
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- Dim cs$, si$
- cs$ = s$
- cs$ = TrimLead0$(cs$)
- cs$ = TrimTail0$(cs$)
- ' for displaying truncated numbers say to 60 digits
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
Post by: jack on June 03, 2021, 09:15:31 pm
here's my version of the Newton-Raphson, I had to use a for loop for the iterations as I found no way to use a do loop but it's much faster especially as the input numbers are larger
Code: QB64: [Select]
- ' divide$ found fix? 2021-06-03 comment in that function
- ' 2021-06-03 update with new sqrRoot$ Function
- _Delay .25
- Dim n$, result$
- Dim t#
- 'remember everything is strings
- Input "Enter a number to find it's square root "; n$
- t# = Timer
- result$ = sqrRoot$(n$)
- t# = Timer
- result$ = sqrt$(n$)
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2")
- other$ = n$
- lastGuess$ = guess$
- sum$ = mr$(guess$, "+", other$)
- guess$ = mr$(sum$, "/", "2")
- other$ = mr$(n$, "/", guess$)
- tmp = mr$(r, "*", r)
- tmp = mr$(tmp, "-", n$)
- r2 = mr$(r, "+", r)
- tmp = mr$(tmp, "/", r2)
- r = mr$(r, "-", tmp)
- Next k 'Loop Until Abs(Val(tmp)) < 1D-100
- sqrt$ = r
- 'strip signs and decimals
- aSgn$ = "": ca$ = ca$
- adp = 0
- bSgn$ = "": cb$ = cb$
- bdp = 0
- 'even up the right sides of decimals if any
- dp = adp + bdp
- 'now according to signs and op$ call add$ or subtr$
- postOp$ = aSgn$ + add$(ca$, cb$)
- Else 'have a case of subtraction
- bSgn$ = ""
- postOp$ = subtr$(cb$, ca$)
- Else 'aSgn = ""
- postOp$ = add$(ca$, cb$)
- Else 'bSgn$ =""
- bSgn$ = "-"
- postOp$ = aSgn$ + add$(ca$, cb$)
- postOp$ = subtr$(ca$, cb$)
- 'put dp back
- mr$ = trim0$(postOp$)
- ' aha! found a bug when d$ gets really huge 100 is no where near enough!!!!
- ' 2021-06-03 fix by adding 100 to len(d$), plus have to go a little past 100 for 100 digit precision
- ' need to go past 100 for 100 precise digits (not decimal places)
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- Next g
- accum$ = build$
- Next dp
- mult$ = accum$
- ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$)
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- Else 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- Function add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$)
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- Dim cs$, si$
- cs$ = s$
- cs$ = TrimLead0$(cs$)
- cs$ = TrimTail0$(cs$)
- ' for displaying truncated numbers say to 60 digits
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
Post by: George McGinn on June 03, 2021, 09:25:56 pm
I have integrated it into your MR program. However, as you will see from the result screen, it seems like it does not clear out what is in the decimal places.
I am using your add, subtract and divide routines, and I'm not yet sure if it is an error with your routines not clearing out the decimal places, or that they are not designed to be nested in a formula (the ones my friend and I wrote for the iPad/iPhone does work properly), or I just don't understand how your program fully works.
I created an OP code ">" to represent Square Root, and the second number is set to "" (can be any value really, as it is never referenced in my routine.
Because the iterations do not stop when dx$ = "10" I get an erroneous result. As you will see I have both the original formula expressed properly in your mr$ format, as well as it broken out in its components based on the order of operations. I get the same results in both, that is I get a carryover of the decimals from the prior iteration.
Code: QB64: [Select]
Code: QB64: [Select]
Code: QB64: [Select]
- DIM x$, dx$
- DIM precision, max_iterations
- x$ = mr$(A$, "/", "2"): precision = 0.001: max_iterations = 30
- '*** Formula: dx = (x - A / x) / 2
- '*** Reduce x by dx: x = x - dx
- dx$ = mr$(mr$(x$, "-", mr$(A$, "/", x$)), "/", "2")
- ' dx$ = mr$(A$, "/", x$)
- ' dx$ = mr$(x$, "-", dx$)
- ' dx$ = mr$(dx$, "/", "2")
- x$ = mr$(x$, "-", dx$)
- PRINT "DX$ = "; dx$
- NEXT i
- root_2$ = x$
Here is my run of the function above. You will see that dx$ is right, but x$ should be just 10. If you want, I can post the entire MR program.
Post by: jack on June 03, 2021, 09:39:39 pm
your string math does not understand numbers in exponential format so when the input number get big and the Sqr of the number is expressed in exponential format then my version fails, I suppose there may be a way to fix that
Post by: jack on June 03, 2021, 09:44:25 pm
r = r - (r^2-x)/(2*r)
in general the inverse function approximation is found by
Xi = Xi - ( f(Xi) -x)/ f ' (Xi)
Post by: bplus on June 03, 2021, 09:50:21 pm
@bplus
your string math does not understand numbers in exponential format so when the input number get big and the Sqr of the number is expressed in exponential format then my version fails, I suppose there may be a way to fix that
Right! String Math means no exponents, it's straight digits and though it takes longer it's accurate with the biggest and smallest of numbers
@jack your code here:
Code: QB64: [Select]
- tmp = mr$(r, "*", r)
- tmp = mr$(tmp, "-", n$)
- r2 = mr$(r, "+", r)
- tmp = mr$(tmp, "/", r2)
- r = mr$(r, "-", tmp)
- Next k 'Loop Until Abs(Val(tmp)) < 1D-100
- sqrt$ = r
VAL() because there are only string type variables
EDIT: well maybe VAL() will work on smaller strings but I don't see it handling a string a 100 digits long?
SQR() heck! that's exactly what we are looking for, of course it's faster but only works for regular type numbers, integers, longs, single, double... not a string of digits.
EDIT: Unless you are somehow dividing the string into workable sections and taking SQR() of those and string together a giant construction like we do with the add$, mult$, subtract$ then I am misunderstanding, apologies.
In fact I have something like that from way back doing SQR, like we learned in school.
Post by: bplus on June 03, 2021, 09:53:23 pm
the Newton-Raphson formula for the square root is
r = r - (r^2-x)/(2*r)
in general the inverse function approximation is found by
Xi = Xi - ( f(Xi) -x)/ f ' (Xi)
I was going by George McGinn example which did seem to be working for big numbers (but not dot 20-0's64 or .0000000000000000000064).
Post by: bplus on June 03, 2021, 10:32:37 pm
@bplus - Here is my version of the Square Root using strings.
I have integrated it into your MR program. However, as you will see from the result screen, it seems like it does not clear out what is in the decimal places.
I am using your add, subtract and divide routines, and I'm not yet sure if it is an error with your routines not clearing out the decimal places, or that they are not designed to be nested in a formula (the ones my friend and I wrote for the iPad/iPhone does work properly), or I just don't understand how your program fully works.
I created an OP code ">" to represent Square Root, and the second number is set to "" (can be any value really, as it is never referenced in my routine.
Because the iterations do not stop when dx$ = "10" I get an erroneous result. As you will see I have both the original formula expressed properly in your mr$ format, as well as it broken out in its components based on the order of operations. I get the same results in both, that is I get a carryover of the decimals from the prior iteration.Code: QB64: [Select]
Code: QB64: [Select]Code: QB64: [Select]
Here is my run of the function above. You will see that dx$ is right, but x$ should be just 10. If you want, I can post the entire MR program.
@George McGinn are we so different?
Code: QB64: [Select]
- Function SRbyNR$ (nmbr$) ' square root by Newton - Ralphson method my interpretation of GeorgeMcGinn
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2") ' get this going first and then try better starting guess later
- loopcnt = loopcnt + 1
- Print "loop cnt"; loopcnt
- 'dx = (x - A / x) / 2: x = x - dx ' Thanks George
- lastGuess$ = guess$
- dx$ = mr$(mr$(guess$, "-", mr$(n$, "/", guess$)), "/", "2")
- guess$ = mr$(guess$, "-", dx$)
- other$ = mr$(n$, "/", guess$) ' try other factor for guess$ sometimes it nails answer without all digits
dx$ = mr$(mr$(guess$, "-", mr$(n$, "/", guess$)), "/", "2") ' yes you can team functions up like this that is fine!
dx$ = mr$(mr$(x$, "-", mr$(A$, "/", x$)), "/", "2")
We just use different variables with the main formula.
This is where we differ, Finished conditional-
yours:
Code: QB64: [Select]
ABS() needs a number type and I don't trust VAL() to handle 100 plus digit strings.Hence I don't trust < to work as expected.
mine:
Code: QB64: [Select]
So I went the route of matching strings down until the first 100 digits of last guess match first 100 digits of current guess. Oddly our method would rather go 100-9's, 1.9999999...'s, than go to 2.0 for the square root of 4!If guess is always growing larger towards 2, the other factor is gaining 0's after decimal such that it looks exactly right when we cut off after 100 digits of 0's (for 2.0000000000...) have been accumulated.
Post by: bplus on June 03, 2021, 10:47:31 pm
Obviously it's slow as hell but the accuracy!
Post by: George McGinn on June 04, 2021, 12:01:48 am
I put your routine in with mine to test it out.
Both produces 2 as the square root of 4, but when I do SRQ(100) I get 5. ... from mine (which is the issue I outlined) but yours does not produce a result.
Are we having the same issue?
Post by: George McGinn on June 04, 2021, 12:06:23 am
As for the question about VAL working on a string of 100 digits/decimal places, it works fine from my testing on both mobile devices (from the original code) to what I ported over to QB64.
I was going by George McGinn example which did seem to be working for big numbers (but not dot 20-0's64 or .0000000000000000000064).
Post by: jack on June 04, 2021, 07:20:19 am
but for completeness here my sqrt$ function that takes care of any exponential notation and is many times faster
Code: QB64: [Select]
- tmp = mr$(r, "*", r)
- tmp = mr$(tmp, "-", n$)
- r2 = mr$(r, "+", r)
- tmp = mr$(tmp, "/", r2)
- r = mr$(r, "-", tmp)
- Next k 'Loop Until Abs(Val(tmp)) < 1D-100
- sqrt$ = r
Quote
Enter a number to find it's square root ? 20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000about 482 times faster
26.375 141421356237309504880168872420969807856967187537694807317667.9737990732478462107038850387534327641572
.0546875 141421356237309504880168872420969807856967187537694807317667.9737990732478462107038850387534327641572
Post by: jack on June 04, 2021, 08:21:09 am
Code: QB64: [Select]
- result$ = mr$(".00000000000000000000000000000000000000000000200000000000000054307978001764", "-", ".000000000000000000000000000000000000000000002")
- Print result$
Quote
.000000000000000000000054307978001764it should be
Quote
.00000000000000000000000000000000000000000000000000000000000054307978001764
Post by: George McGinn on June 04, 2021, 09:46:15 am
I ran it and it does give me the correct answer for SQR(100) where mine is having an issue where the decimals are being carried over (might be part of a subtraction problem in the Math Regulator, but not sure yet, and I did see your post about an issue with the subtraction function).
I am working on converting my n'th root function to string, unless you have one as well. I would test it out along side mine, as the issue I am having with my square root function I believe I will also have with my n'th root function.
@bplus it seems that you didn't bother to run the code I posted, instead you jump to conclusions.
but for completeness here my sqrt$ function that takes care of any exponential notation and is many times fasterCode: QB64: [Select]about 482 times faster
Post by: bplus on June 04, 2021, 10:42:04 am
@bplus it seems that you didn't bother to run the code I posted, instead you jump to conclusions.
...
@jack
I did run the code you provided in reply #33
https://www.qb64.org/forum/index.php?topic=2921.msg133047#msg133047
I suspected it would not work with numbers outside the range of doubles and floats so first I tried 100 with an even amount of zeros added on, I didn't count then but I double checked with 100 + 30 zeros a second time, then I ran a small number .0000000000000000000064 (that's suppose to be 20 zeroes between decimal and 64.
I posted my first results in reply #37
https://www.qb64.org/forum/index.php?topic=2921.msg133053#msg133053
Just to confirm what I saw yesterday I ran the code from reply #33 again this for sure 100 then 30 zeros and . 20-0's and 64
Again my functions takes a very long time but result looks correct and your function doesn't take a long time but results are do not look close to correct:
I have not run the code that corrects for exponents (reply #43 posted this AM) because I am just getting to it now your sqr(2) times 10 to some hefty amount of even number (I assume by the answers) looks very impressive specially with time.
Please forget my comments in #37 I don't know what the heck you're doing in 3 iterations, let the screen shot of my test of your code speak for itself.
Post by: bplus on June 04, 2021, 10:48:57 am
bplus, there's a bug in your subtract routineCode: QB64: [Select]the outputit should be
Confirmed! thanks for heads up.
Apparently the Forum editor can only Quote one Quote box at a time.
Post by: jack on June 04, 2021, 11:48:44 am
there's a loss of precision with roots higher than 50
Code: QB64: [Select]
- ' divide$ found fix? 2021-06-03 comment in that function
- ' 2021-06-03 update with new sqrRoot$ Function
- 'Screen _NewImage(1200, 700, 32)
- '_Delay .25
- '_ScreenMove _Middle
- Dim n$, result$
- Dim t#
- 'Do
- ' 'remember everything is strings
- ' Input "Enter a number to find it's square root "; n$
- ' If n$ = "" Then End
- ' t# = Timer
- ' result$ = sqrRoot$(n$)
- ' Print Timer - t#, result$
- ' t# = Timer
- ' result$ = sqrt$(n$)
- ' Print Timer - t#, result$
- ' Print "Length ="; Len(result$)
- ' Print
- 'Loop
- 'Print approx_power(x#, y#), x# ^ (1 / y#)
- n$ = "2"
- t# = Timer
- result$ = approx_powers$(n$, 2)
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2")
- other$ = n$
- lastGuess$ = guess$
- sum$ = mr$(guess$, "+", other$)
- guess$ = mr$(sum$, "/", "2")
- other$ = mr$(n$, "/", guess$)
- 'take x to an integer power
- y = x
- z = 1#
- n = n \ 2
- y = y * y
- n = n - 1
- z = y * z
- ipower = 1# / z
- ipower = z
- a = x#: b = 1# / y#
- tmp = (tmp - 1072632447) * b
- tmp = tmp + 1072632447
- a = a - (ipower(a, y#) - x#) / (y# * ipower(a, y# - 1))
- a = a - (ipower(a, y#) - x#) / (y# * ipower(a, y# - 1))
- a = a - (ipower(a, y#) - x#) / (y# * ipower(a, y# - 1))
- a = a - (ipower(a, y#) - x#) / (y# * ipower(a, y# - 1))
- approx_power = a
- 'take x to an integer power
- y = x
- z = "1"
- n = n \ 2
- y = mr$(y, "*", y)
- n = n - 1
- z = mr$(y, "*", z)
- ipow = mr$("1", "/", z)
- ipow = z
- a = approx_power#(a, b)
- temp = ipow$(r, y%)
- temp = mr$(temp, "-", x$)
- r2 = ipow$(r, y% - 1)
- r2 = mr$(ys, "*", r2)
- r2 = mr$(temp, "/", r2)
- r = mr$(r, "-", r2)
- Next k
- approx_powers = r
- tmp = mr$(r, "*", r)
- tmp = mr$(tmp, "-", n$)
- r2 = mr$(r, "+", r)
- tmp = mr$(tmp, "/", r2)
- r = mr$(r, "-", tmp)
- Next k 'Loop Until Abs(Val(tmp)) < 1D-100
- sqrt$ = r
- 'strip signs and decimals
- aSgn$ = "": ca$ = ca$
- adp = 0
- bSgn$ = "": cb$ = cb$
- bdp = 0
- 'even up the right sides of decimals if any
- dp = adp + bdp
- 'now according to signs and op$ call add$ or subtr$
- postOp$ = aSgn$ + add$(ca$, cb$)
- Else 'have a case of subtraction
- bSgn$ = ""
- postOp$ = subtr$(cb$, ca$)
- Else 'aSgn = ""
- postOp$ = add$(ca$, cb$)
- Else 'bSgn$ =""
- bSgn$ = "-"
- postOp$ = aSgn$ + add$(ca$, cb$)
- postOp$ = subtr$(ca$, cb$)
- 'put dp back
- mr$ = trim0$(postOp$)
- ' aha! found a bug when d$ gets really huge 100 is no where near enough!!!!
- ' 2021-06-03 fix by adding 100 to len(d$), plus have to go a little past 100 for 100 digit precision
- ' need to go past 100 for 100 precise digits (not decimal places)
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- Next g
- accum$ = build$
- Next dp
- mult$ = accum$
- ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$)
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- Else 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- Function add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$)
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- Dim cs$, si$
- cs$ = s$
- cs$ = TrimLead0$(cs$)
- cs$ = TrimTail0$(cs$)
- ' for displaying truncated numbers say to 60 digits
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
Post by: bplus on June 04, 2021, 06:46:13 pm
I should have checked way larger and smaller numbers with it. I think I just checked it with QB64 Doubles or Floats for errors but the bug doesn't show until numbers are longer than 18 digits.
Apologies to all who wasted time working that code.
Still, our goal is a good one I think.
PS This explains why the attempts with Newton-Raphson were not working with Mr$() Function calls and why I was getting good sqrRoots because I was using the Average Method that did not use subtraction.
Post by: George McGinn on June 05, 2021, 01:16:38 am
Also, I noticed that for the power## function, when I do 1.2^5 [mr$("1.2", "^", "5")] I get the right digits, but the decimal place isn't put back into the final result (see screen print).
[ This attachment cannot be displayed inline in 'Print Page' view ]
Post by: bplus on June 05, 2021, 11:07:29 pm
The bad news, it is now taking the inverse of STx number to see 115 terms of Fibonacci series (or is it sequence) about 30 secs to calculate, before it was up in a sneeze. It looks different also at the end but the same 115 terms of Fibonacci can still be found.
OK so the first line in subtr$() fixes the bug that jack pointed out that I confirmed and it also fixes my version of George's version of Newton-Raphson estimates of SQR() but it is definitely slowed down. We now get same sqr roots for 100 + 30-0's and .20-0's 64 for both versions.
Anyway here is the code checks and tests:
Code: QB64: [Select]
- ' divide$ found fix? 2021-06-03 comment in that function
- ' 2021-06-03 update with new sqrRoot$ Function
- _Delay .25
- ' jack error reported 2021-06-04 confirmed! fixed
- Print mr$(".00000000000000000000000000000000000000000000200000000000000054307978001764", "-", ".000000000000000000000000000000000000000000002")
- Print ".00000000000000000000000000000000000000000000000000000000000054307978001764"
- Dim r$, ruler$
- ruler$ = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890" + Chr$(10)
- ruler$ = ruler$ + "0 1 2 3 4 5 6 7 8 9 10 11 12"
- ' debug tests
- Print ruler$
- '-.00071
- ' .00036000000000000000000000000000000000009
- Print "-.00034999999999999999999999999999999999991"
- Print ruler$
- 'testing a different subtract sub
- ' jack error reported 2021-06-04 confirmed! variation below
- r$ = mr$(".00000000200000000000000054307978001764", "-", ".0000000020000000000000001") '16 0 wrong 8 wrong
- Print " mr$ rtnd:"; r$
- ' .0000000020000000000000001
- ' .00000000200000000000000054307978001764
- r$ = mr$(".00000000000000000100000000000000000011", "-", ".000000000000000001000000000000000001") ' bad too
- Print " mr$ rtnd:"; r$
- ' ".000000000000000001000000000000000001"
- Print " compare:-.00000000000000000000000000000000000089"
- r$ = mr$(".00000000000000000100000000000000000111", "-", ".000000000000000002000000000000000001")
- ' ".000000000000000002000000000000000001"
- ' ".00000000000000000100000000000000000111"
- ' ".00000000000000000099999999999999999989"
- Print " mr$ rtnd:"; r$
- Print " compare:-.00000000000000000099999999999999999989"
- r$ = mr$(".00000000000000000000000000999", "-", "1")
- '-1.00000000000000000000000000000000000000000
- ' .00000000000000000000000000999
- ' -.99999999999999999999999999001
- Print " mr$ rtnd:"; r$
- Print " compare:-.99999999999999999999999999001"
- r$ = mr$("1", "+", "-1000000000000000000000000000000000000000")
- Print " mr$ rtnd:"; r$
- '1000000000000000000000000000000000000000
- '-999999999999999999999999999999999999999
- Print " compare:-999999999999999999999999999999999999999"
- ' check jack problems with FB translation 2021-06-03 errors must be in FB trans from QB64
- Print ruler$
- Print ruler$
- Print "zzz... see inverse of STx number now takes close to 30 secs with fixed subtr$() sub,"
- Print "Use to come up in a sneeze! It also looks different way more space on end but still"
- Print "can find 115 Fibonacci terms in it."
- Print " The only difference is I am not trimming leading 0's in subst$() function!"
- Dim n$, result$
- 'remember everything is strings
- Input "Enter a number to find it's square root "; n$
- result$ = sqrRoot$(n$)
- Print result$
- _Delay 2
- result$ = SRbyNR$(n$)
- Print result$
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2")
- other$ = n$
- loopcnt = loopcnt + 1
- Print "loop cnt"; loopcnt
- sqrRoot$ = Mid$(other$, 1, 101) + imaginary$ ' try other factor for guess$ sometimes it nails answer without all digits
- lastGuess$ = guess$
- sum$ = mr$(guess$, "+", other$)
- guess$ = mr$(sum$, "/", "2")
- other$ = mr$(n$, "/", guess$)
- Function SRbyNR$ (nmbr$) ' square root by Newton - Ralphson method my interpretation of GeorgeMcGinn
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2") ' get this going first and then try better starting guess later
- loopcnt = loopcnt + 1
- Print "loop cnt"; loopcnt
- 'dx = (x - A / x) / 2: x = x - dx ' Thanks George
- lastGuess$ = guess$
- dx$ = mr$(mr$(guess$, "-", mr$(n$, "/", guess$)), "/", "2")
- guess$ = mr$(guess$, "-", dx$)
- other$ = mr$(n$, "/", guess$) ' try other factor for guess$ sometimes it nails answer without all digits
- 'strip signs and decimals
- aSgn$ = "": ca$ = ca$
- adp = 0
- bSgn$ = "": cb$ = cb$
- bdp = 0
- 'even up the right sides of decimals if any
- dp = adp + bdp
- 'now according to signs and op$ call add$ or subtr$
- postOp$ = aSgn$ + add$(ca$, cb$)
- Else 'have a case of subtraction
- bSgn$ = ""
- postOp$ = subtr$(cb$, ca$)
- Else 'aSgn = ""
- postOp$ = add$(ca$, cb$)
- Else 'bSgn$ =""
- bSgn$ = "-"
- postOp$ = aSgn$ + add$(ca$, cb$)
- postOp$ = subtr$(ca$, cb$)
- 'put dp back
- mr$ = trim0$(postOp$)
- ' aha! found a bug when d$ gets really huge 100 is no where near enough!!!!
- ' 2021-06-03 fix by adding 100 to len(d$), plus have to go a little past 100 for 100 digit precision
- ' need to go past 100 for 100 precise digits (not decimal places)
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- Next g
- accum$ = build$
- Next dp
- mult$ = accum$
- 'ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$) 'orig with decent square root speed
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- Else 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- Function add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$)
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- Dim cs$, si$
- cs$ = s$
- cs$ = TrimLead0$(cs$)
- cs$ = TrimTail0$(cs$)
- ' for displaying truncated numbers say to 60 digits
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
Post by: jack on June 06, 2021, 02:11:38 am
I don't understand your nInverse function, here's how I would implement the reciprocal
pseudo code
dim x as double
x=1#/val(n$) ' approximation
r$=_trim$(str$(x)) '<< you need to sift-out exponential notation
' Newton-Raphson iteration to improve the reciprocal - it doubles the accuracy per iteration
do
r$=r$*(2-n$*r$)
loop until satisfied '<< (2-n$*r$) approaches 1
or
do
r$=r$+r$*(1-r$*n$)
loop until satisfied '<<r$*(1-r$*n$) approaches 0
if you do r$=r$+r$*(1-r$*n$) then you could check r$*(1-r$*n$) until it's small enough
3 iterations would give over 120 digits accuracy
Post by: jack on June 06, 2021, 04:52:01 am
Code: QB64: [Select]
- Print mr$("1.000000000000000000000001000000000000000000000001", "*", "0.000000000000000000000000000000000000000000000001")
.1000000000000000000000001000000000000000000000001
was trying to test my nInverse but it fails due to the multiply bug
Code: QB64: [Select]
- r2 = mr$(n$, "*", r)
- r2 = mr$("2", "-", r2)
- r = mr$(r, "*", r2)
- Next k
- nInverse2$ = r
Post by: bplus on June 06, 2021, 01:02:49 pm
@jack I like your inverse function and started playing with in attempts to control when it should quit.
It works well finding inverse of STx number and the 115 terms of Fibonacci in that sequence.
I am not satisfied with significant digits because a difference between 816 and 817 was just one more iteration in your code loop yet it went from finding 64 terms in 4.22 secs to all 115 terms in around 13 secs. My inverse with fixed subtr$() was taking over 19 secs and needing about 2785 digits.
So your inverse better. I see you are working on reciprical, interesting!
Code: QB64: [Select]
- ' divide$ found fix? 2021-06-03 comment in that function
- ' 2021-06-03 update with new sqrRoot$ Function
- ' 2021-06-06 fixed divide, subtr and mult, all were trimming lead 0's and messing up decimal settings.
- ' 2021-06-06 test jack's nInverse2$() on STx # to find 115 terms of Fibannci.
- _Delay .25
- ' jack error reported 2021-06-04 confirmed! fixed
- 'Print mr$(".00000000000000000000000000000000000000000000200000000000000054307978001764", "-", ".000000000000000000000000000000000000000000002")
- 'Print ".00000000000000000000000000000000000000000000000000000000000054307978001764"
- Dim r$, ruler$
- ruler$ = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890" + Chr$(10)
- ruler$ = ruler$ + "0 1 2 3 4 5 6 7 8 9 10 11 12"
- ' debug tests
- 'Print mr$("-5", "+", "-2100"), " OK if -2105"
- 'Print mr$("." + String$(20, "0") + "1", "+", "1" + String$(40, "0") + "1") ' first real test of add
- 'Print ruler$
- 'Print Val("." + String$(20, "0") + "1") + Val("1" + String$(40, "0") + "1") ' test print of big and small val
- 'Print mr$("-.00071", "+", ".00036" + String$(35, "0") + "9")
- '-.00071
- ' .00036000000000000000000000000000000000009
- 'Print "-.00034999999999999999999999999999999999991"
- 'Print ruler$
- 'testing a different subtract sub
- 'Print mr$("10", "-", "5"), " 5 OK"
- 'Print mr$("-10", "+", "5"), " -5 OK"
- 'Print mr$("-10", "-", "-5"), " -5 OK"
- 'Print mr$("-10", "-", "5"), " -15 OK added"
- 'Print mr$("10", "-", "-5"), " 15 OK added"
- 'Print mr$("-.010", "-", "-5"), "4.99 OK"
- 'Print mr$("-.010", "-", "5"), "-5.01 OK just added"
- 'Print mr$(".010", "-", "5"), " -4.99 OK"
- ' jack error reported 2021-06-04 confirmed! variation below
- 'r$ = mr$(".00000000200000000000000054307978001764", "-", ".0000000020000000000000001") '16 0 wrong 8 wrong
- 'Print " mr$ rtnd:"; r$
- 'Print " compare:.00000000000000000000000044307978001764" ' 2021-06-05 finally!
- ' .0000000020000000000000001
- ' .00000000200000000000000054307978001764
- 'r$ = mr$(".00000000000000000100000000000000000011", "-", ".000000000000000001000000000000000001") ' bad too
- 'Print " mr$ rtnd:"; r$
- ' ".000000000000000001000000000000000001"
- 'Print " compare:-.00000000000000000000000000000000000089"
- 'r$ = mr$(".00000000000000000100000000000000000111", "-", ".000000000000000002000000000000000001")
- ' ".000000000000000002000000000000000001"
- ' ".00000000000000000100000000000000000111"
- ' ".00000000000000000099999999999999999989"
- 'Print " mr$ rtnd:"; r$
- 'Print " compare:-.00000000000000000099999999999999999989"
- 'r$ = mr$(".00000000000000000000000000999", "-", "1")
- '-1.00000000000000000000000000000000000000000
- ' .00000000000000000000000000999
- ' -.99999999999999999999999999001
- 'Print " mr$ rtnd:"; r$
- 'Print " compare:-.99999999999999999999999999001"
- 'r$ = mr$("1", "+", "-1000000000000000000000000000000000000000")
- 'Print " mr$ rtnd:"; r$
- '1000000000000000000000000000000000000000
- '-999999999999999999999999999999999999999
- 'Print " compare:-999999999999999999999999999999999999999"
- ' check jack problems with FB translation 2021-06-03 errors must be in FB trans from QB64
- 'Print Mid$(mr$(" .1", "/", "3"), 1, 100) ' too long?
- 'Print Mid$(mr$("1.1", "/", "9"), 1, 100)
- 'Print Mid$(mr$("1.38", "/", "1.2"), 1, 100)
- 'Print ruler$
- ' another error reported by jack 2021-06-06 fixed (same problem as subtr$)
- Print mr$("1.000000000000000000000001000000000000000000000001", "*", ".000000000000000000000000000000000000000000000001")
- Print ".000000000000000000000000000000000000000000000001"
- Print " 1000000000000000000000001000000000000000000000001"
- Print ruler$
- 'Print "checking inverse of 50 = .02 "; nInverse$("50", 20) 'OK .020000... length 20
- 'Print ruler$
- 'Print
- 'Print "zzz... see inverse of STx number now takes close to 30 secs with fixed subtr$() sub,"
- 'Print "Use to come up in a sneeze! It also looks different way more space on end but still"
- 'Print "can find 115 Fibonacci terms in it."
- 'Print " The only difference is I am not trimming leading 0's in subst$() function!"
- 'Sleep
- 'Cls
- 'inverseSTx$ = nInverse$("999999999999999999999998999999999999999999999999", 2785) ' wow big delay! 19.52 secs +-
- inverseSTx$ = nInverse2$("999999999999999999999998999999999999999999999999", 817)
- ' 816 in 4.22 secs only 64 terms 817 sigDigits matching in 12.93 secs gets all 115 Fibonacci Terms
- f1$ = "1"
- f2$ = "1"
- startSearch = 1
- termN = 2
- searchFor$ = mr$(f1$, "+", f2$)
- termN = termN + 1
- f1$ = f2$
- f2$ = searchFor$
- Print searchFor$; " not found."
- Print "Inverse time:"; done
- 'Dim n$, result$
- 'Do
- ' 'remember everything is strings
- ' Input "Enter a number to find it's square root "; n$
- ' If n$ = "" Then End
- ' result$ = sqrRoot$(n$)
- ' Print result$
- ' Print "Length ="; Len(result$)
- ' _Delay 2
- ' result$ = SRbyNR$(n$)
- ' Print result$
- ' Print "Length ="; Len(result$)
- ' Print
- 'Loop
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2")
- other$ = n$
- loopcnt = loopcnt + 1
- Print "loop cnt"; loopcnt
- sqrRoot$ = Mid$(other$, 1, 101) + imaginary$ ' try other factor for guess$ sometimes it nails answer without all digits
- lastGuess$ = guess$
- sum$ = mr$(guess$, "+", other$)
- guess$ = mr$(sum$, "/", "2")
- other$ = mr$(n$, "/", guess$)
- Function SRbyNR$ (nmbr$) ' square root by Newton - Ralphson method my interpretation of GeorgeMcGinn
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2") ' get this going first and then try better starting guess later
- loopcnt = loopcnt + 1
- Print "loop cnt"; loopcnt
- 'dx = (x - A / x) / 2: x = x - dx ' Thanks George
- lastGuess$ = guess$
- dx$ = mr$(mr$(guess$, "-", mr$(n$, "/", guess$)), "/", "2")
- guess$ = mr$(guess$, "-", dx$)
- other$ = mr$(n$, "/", guess$) ' try other factor for guess$ sometimes it nails answer without all digits
- 'jacks nInverse2$ modified from using 7 interations to ending when a certain amount of significant digits match between r's
- lastR = r
- r2 = mr$(n$, "*", r)
- r2 = mr$("2", "-", r2)
- r = mr$(r, "*", r2)
- nInverse2$ = r
- 'strip signs and decimals
- aSgn$ = "": ca$ = ca$
- adp = 0
- bSgn$ = "": cb$ = cb$
- bdp = 0
- 'even up the right sides of decimals if any
- dp = adp + bdp
- 'now according to signs and op$ call add$ or subtr$
- postOp$ = aSgn$ + add$(ca$, cb$)
- Else 'have a case of subtraction
- bSgn$ = ""
- postOp$ = subtr$(cb$, ca$)
- Else 'aSgn = ""
- postOp$ = add$(ca$, cb$)
- Else 'bSgn$ =""
- bSgn$ = "-"
- postOp$ = aSgn$ + add$(ca$, cb$)
- postOp$ = subtr$(ca$, cb$)
- 'put dp back
- mr$ = trim0$(postOp$)
- ' aha! found a bug when d$ gets really huge 100 is no where near enough!!!!
- ' 2021-06-03 fix by adding 100 to len(d$), plus have to go a little past 100 for 100 digit precision
- ' need to go past 100 for 100 precise digits (not decimal places)
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- ' fixed mult$ don't trim lead 0's 2021-06-06
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- Next g
- accum$ = build$
- Next dp
- mult$ = accum$
- 'ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$) 'orig with decent square root speed
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- Else 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- Function add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$) a and b have decimal removed and a and b lengths aligned on right
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- Dim cs$, si$
- cs$ = s$
- cs$ = TrimLead0$(cs$)
- cs$ = TrimTail0$(cs$)
- ' for displaying truncated numbers say to 60 digits
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
Post by: jack on June 06, 2021, 01:45:34 pm
if you would set all your routines to a limit of say 128 digits - integer + fractional, then your operations would be relatively fast, nInverse would require only 3 iterations to give 128 digits of accuracy - you could dispense the loop and loop-test
as it is, your strings grow huge and the routines become very slow, that's why in my sqrt$ routine I would keep trimming the resulting strings
< edit > or you could go to 256 digits, nInverse would only require 4 iterations
Post by: jack on June 06, 2021, 05:37:13 pm
Code: QB64: [Select]
- ' divide$ found fix? 2021-06-03 comment in that function
- ' 2021-06-03 update with new sqrRoot$ Function
- ' 2021-06-06 fixed divide, subtr and mult, all were trimming lead 0's and messing up decimal settings.
- ' 2021-06-06 test jack's nInverse2$() on STx # to find 115 terms of Fibannci.
- _Delay .25
- ' jack error reported 2021-06-04 confirmed! fixed
- 'Print mr$(".00000000000000000000000000000000000000000000200000000000000054307978001764", "-", ".000000000000000000000000000000000000000000002")
- 'Print ".00000000000000000000000000000000000000000000000000000000000054307978001764"
- Dim r$, ruler$
- ruler$ = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890" + Chr$(10)
- ruler$ = ruler$ + "0 1 2 3 4 5 6 7 8 9 10 11 12"
- ' debug tests
- 'Print mr$("-5", "+", "-2100"), " OK if -2105"
- 'Print mr$("." + String$(20, "0") + "1", "+", "1" + String$(40, "0") + "1") ' first real test of add
- 'Print ruler$
- 'Print Val("." + String$(20, "0") + "1") + Val("1" + String$(40, "0") + "1") ' test print of big and small val
- 'Print mr$("-.00071", "+", ".00036" + String$(35, "0") + "9")
- '-.00071
- ' .00036000000000000000000000000000000000009
- 'Print "-.00034999999999999999999999999999999999991"
- 'Print ruler$
- 'testing a different subtract sub
- 'Print mr$("10", "-", "5"), " 5 OK"
- 'Print mr$("-10", "+", "5"), " -5 OK"
- 'Print mr$("-10", "-", "-5"), " -5 OK"
- 'Print mr$("-10", "-", "5"), " -15 OK added"
- 'Print mr$("10", "-", "-5"), " 15 OK added"
- 'Print mr$("-.010", "-", "-5"), "4.99 OK"
- 'Print mr$("-.010", "-", "5"), "-5.01 OK just added"
- 'Print mr$(".010", "-", "5"), " -4.99 OK"
- ' jack error reported 2021-06-04 confirmed! variation below
- 'r$ = mr$(".00000000200000000000000054307978001764", "-", ".0000000020000000000000001") '16 0 wrong 8 wrong
- 'Print " mr$ rtnd:"; r$
- 'Print " compare:.00000000000000000000000044307978001764" ' 2021-06-05 finally!
- ' .0000000020000000000000001
- ' .00000000200000000000000054307978001764
- 'r$ = mr$(".00000000000000000100000000000000000011", "-", ".000000000000000001000000000000000001") ' bad too
- 'Print " mr$ rtnd:"; r$
- ' ".000000000000000001000000000000000001"
- 'Print " compare:-.00000000000000000000000000000000000089"
- 'r$ = mr$(".00000000000000000100000000000000000111", "-", ".000000000000000002000000000000000001")
- ' ".000000000000000002000000000000000001"
- ' ".00000000000000000100000000000000000111"
- ' ".00000000000000000099999999999999999989"
- 'Print " mr$ rtnd:"; r$
- 'Print " compare:-.00000000000000000099999999999999999989"
- 'r$ = mr$(".00000000000000000000000000999", "-", "1")
- '-1.00000000000000000000000000000000000000000
- ' .00000000000000000000000000999
- ' -.99999999999999999999999999001
- 'Print " mr$ rtnd:"; r$
- 'Print " compare:-.99999999999999999999999999001"
- 'r$ = mr$("1", "+", "-1000000000000000000000000000000000000000")
- 'Print " mr$ rtnd:"; r$
- '1000000000000000000000000000000000000000
- '-999999999999999999999999999999999999999
- 'Print " compare:-999999999999999999999999999999999999999"
- ' check jack problems with FB translation 2021-06-03 errors must be in FB trans from QB64
- 'Print Mid$(mr$(" .1", "/", "3"), 1, 100) ' too long?
- 'Print Mid$(mr$("1.1", "/", "9"), 1, 100)
- 'Print Mid$(mr$("1.38", "/", "1.2"), 1, 100)
- 'Print ruler$
- ' another error reported by jack 2021-06-06 fixed (same problem as subtr$)
- Print mr$("1.000000000000000000000001000000000000000000000001", "*", ".000000000000000000000000000000000000000000000001")
- Print ".000000000000000000000000000000000000000000000001"
- Print " 1000000000000000000000001000000000000000000000001"
- Print ruler$
- 'Print "checking inverse of 50 = .02 "; nInverse$("50", 20) 'OK .020000... length 20
- 'Print ruler$
- 'Print
- 'Print "zzz... see inverse of STx number now takes close to 30 secs with fixed subtr$() sub,"
- 'Print "Use to come up in a sneeze! It also looks different way more space on end but still"
- 'Print "can find 115 Fibonacci terms in it."
- 'Print " The only difference is I am not trimming leading 0's in subst$() function!"
- 'Sleep
- 'Cls
- 'inverseSTx$ = nInverse$("999999999999999999999998999999999999999999999999", 2785) ' wow big delay! 19.52 secs +-
- inverseSTx$ = nInverse2$("999999999999999999999998999999999999999999999999", 817)
- ' 816 in 4.22 secs only 64 terms 817 sigDigits matching in 12.93 secs gets all 115 Fibonacci Terms
- j = 1
- j = j + 48
- 'f1$ = "1"
- 'f2$ = "1"
- 'startSearch = 1
- 'termN = 2
- 'Do
- ' searchFor$ = mr$(f1$, "+", f2$)
- ' find = InStr(startSearch, inverseSTx$, searchFor$)
- ' If find Then
- ' termN = termN + 1
- ' Print "Term Number"; termN; " = "; searchFor$; " found at"; find
- ' f1$ = f2$
- ' f2$ = searchFor$
- ' startSearch = find + Len(searchFor$)
- ' Else
- ' Print searchFor$; " not found."
- ' Exit Do
- ' End If
- 'Loop
- 'Print "Inverse time:"; done
- 'Dim n$, result$
- 'Do
- ' 'remember everything is strings
- ' Input "Enter a number to find it's square root "; n$
- ' If n$ = "" Then End
- ' result$ = sqrRoot$(n$)
- ' Print result$
- ' Print "Length ="; Len(result$)
- ' _Delay 2
- ' result$ = SRbyNR$(n$)
- ' Print result$
- ' Print "Length ="; Len(result$)
- ' Print
- 'Loop
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2")
- other$ = n$
- loopcnt = loopcnt + 1
- Print "loop cnt"; loopcnt
- sqrRoot$ = Mid$(other$, 1, 101) + imaginary$ ' try other factor for guess$ sometimes it nails answer without all digits
- lastGuess$ = guess$
- sum$ = mr$(guess$, "+", other$)
- guess$ = mr$(sum$, "/", "2")
- other$ = mr$(n$, "/", guess$)
- Function SRbyNR$ (nmbr$) ' square root by Newton - Ralphson method my interpretation of GeorgeMcGinn
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2") ' get this going first and then try better starting guess later
- loopcnt = loopcnt + 1
- Print "loop cnt"; loopcnt
- 'dx = (x - A / x) / 2: x = x - dx ' Thanks George
- lastGuess$ = guess$
- dx$ = mr$(mr$(guess$, "-", mr$(n$, "/", guess$)), "/", "2")
- guess$ = mr$(guess$, "-", dx$)
- other$ = mr$(n$, "/", guess$) ' try other factor for guess$ sometimes it nails answer without all digits
- 'jacks nInverse2$ modified from using 7 interations to ending when a certain amount of significant digits match between r's
- lastR = r
- r2 = mr$(n$, "*", r)
- r2 = mr$("2", "-", r2)
- r = mr$(r, "*", r2)
- nInverse2$ = r
- 'strip signs and decimals
- aSgn$ = "": ca$ = ca$
- adp = 0
- bSgn$ = "": cb$ = cb$
- bdp = 0
- 'even up the right sides of decimals if any
- dp = adp + bdp
- 'now according to signs and op$ call add$ or subtr$
- postOp$ = aSgn$ + add$(ca$, cb$)
- Else 'have a case of subtraction
- bSgn$ = ""
- postOp$ = subtr$(cb$, ca$)
- Else 'aSgn = ""
- postOp$ = add$(ca$, cb$)
- Else 'bSgn$ =""
- bSgn$ = "-"
- postOp$ = aSgn$ + add$(ca$, cb$)
- postOp$ = subtr$(ca$, cb$)
- 'put dp back
- mr$ = trim0$(postOp$)
- ' aha! found a bug when d$ gets really huge 100 is no where near enough!!!!
- ' 2021-06-03 fix by adding 100 to len(d$), plus have to go a little past 100 for 100 digit precision
- ' need to go past 100 for 100 precise digits (not decimal places)
- ndi$ = mult$(n$, di$)
- divide$ = trim0$(ndi$)
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr$(r$, mult$(d$, n$)) 'r = r -d*n
- r$ = r$ + "0" 'add another place
- ' fixed mult$ don't trim lead 0's 2021-06-06
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- Next g
- accum$ = build$
- Next dp
- mult$ = accum$
- 'ts$ = TrimLead0$(sum$): tm$ = TrimLead0$(minus$) 'orig with decent square root speed
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = "-"
- Else 'sum is bigger
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = sign$ + result$
- Function add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
- 'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
- ' String Math Helpers -----------------------------------------------
- 'this function needs TrimLead0$(s$) a and b have decimal removed and a and b lengths aligned on right
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- ' ------------------------------------- use these for final display
- i = 1: find = 0
- i = i + 1: find = 1
- TrimTail0$ = copys$
- i = i - 1: find = 1
- Dim cs$, si$
- cs$ = s$
- cs$ = TrimLead0$(cs$)
- cs$ = TrimTail0$(cs$)
- ' for displaying truncated numbers say to 60 digits
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
Post by: NOVARSEG on June 06, 2021, 11:32:23 pm
https://www.qb64.org/forum/index.php?topic=3716.15
Post by: bplus on June 14, 2021, 04:04:41 pm
Code: QB64: [Select]
- _Title "String Math 2021-06-14" ' b+ from SM2 (2021 June) a bunch of experiments to fix and improve speeds.
- ' June 2021 fix some old String Math procedures, better nInverse with new LT frunction, remove experimental procedures.
- ' Now with decent sqrRoot it works independent of Mr$() = Math Regulator that handles signs and decimals and calls to
- ' add$(), subtr$, mult$, divide$ (100 significant digits), add$(), subtr$, mult$ are exact!
- ' If you need higher precsion divide, I recommend use nInverse on denominator (integer)
- ' then add sign and decimal and mult$() that number with numerator to get divsion answer in higher precision than 100.
- ' (See how Mr$() handles division and just call nInverse$ with what precision you need.)
- ' The final function showDP$() is for displaying these number to a set amount of Decimal Places.
- ' The main code is sampler of tests performed with these functions.
- _Delay .25
- 'test new stuff
- 'Print mult3$("11", "1001")
- 'End
- Dim r$, ruler$
- ruler$ = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890" + Chr$(10)
- ruler$ = ruler$ + "0 1 2 3 4 5 6 7 8 9 10 11 12"
- ' jack error reported 2021-06-04 confirmed! fixed
- Print mr$(".00000000000000000000000000000000000000000000200000000000000054307978001764", "-", ".000000000000000000000000000000000000000000002")
- Print ".00000000000000000000000000000000000000000000000000000000000054307978001764"
- ' debug tests
- Print ruler$
- '-.00071
- ' .00036000000000000000000000000000000000009
- Print "-.00034999999999999999999999999999999999991"
- 'testing a different subtract sub
- ' jack error reported 2021-06-04 confirmed! variation below
- r$ = mr$(".00000000200000000000000054307978001764", "-", ".0000000020000000000000001") '16 0 wrong 8 wrong
- Print " mr$ rtnd:"; r$
- ' .0000000020000000000000001
- ' .00000000200000000000000054307978001764
- r$ = mr$(".00000000000000000100000000000000000011", "-", ".000000000000000001000000000000000001") ' bad too
- Print " mr$ rtnd:"; r$
- ' ".000000000000000001000000000000000001"
- Print " compare:-.00000000000000000000000000000000000089"
- r$ = mr$(".00000000000000000100000000000000000111", "-", ".000000000000000002000000000000000001")
- ' ".000000000000000002000000000000000001"
- ' ".00000000000000000100000000000000000111"
- ' ".00000000000000000099999999999999999989"
- Print " mr$ rtnd:"; r$
- Print " compare:-.00000000000000000099999999999999999989"
- r$ = mr$(".00000000000000000000000000999", "-", "1")
- '-1.00000000000000000000000000000000000000000
- ' .00000000000000000000000000999
- ' -.99999999999999999999999999001
- Print " mr$ rtnd:"; r$
- Print " compare:-.99999999999999999999999999001"
- r$ = mr$("1", "+", "-1000000000000000000000000000000000000000")
- Print " mr$ rtnd:"; r$
- '1000000000000000000000000000000000000000
- '-999999999999999999999999999999999999999
- Print " compare:-999999999999999999999999999999999999999"
- ' check jack problems with FB translation 2021-06-03 errors must be in FB trans from QB64
- ' another error reported by jack 2021-06-06 fixed (same problem as subtr$)
- Print mr$("1.000000000000000000000001000000000000000000000001", "*", ".000000000000000000000000000000000000000000000001")
- Print ".000000000000000000000000000000000000000000000001"
- Print " 1000000000000000000000001000000000000000000000001"
- Print ruler$
- Print "zzz... see inverse of STx number now takes 2.2 secs with fixed subtr$() sub,"
- Print "can find 115 Fibonacci terms in it."
- inverseSTx$ = nInverse$("999999999999999999999998999999999999999999999999", 2785) ' now 2.2 secs with new subtr from 19 secs
- 'inverseSTx$ = nInverse2$("999999999999999999999998999999999999999999999999", 817) ' 13 sec damn added 7 secs! now 19.xx
- ' 816 in 4.22 secs only 64 terms 817 sigDigits matching in 12.93 secs gets all 115 Fibonacci Terms
- f1$ = "1"
- f2$ = "1"
- startSearch = 1
- termN = 2
- searchFor$ = mr$(f1$, "+", f2$)
- termN = termN + 1
- f1$ = f2$
- f2$ = searchFor$
- Print searchFor$; " not found."
- ' test factorial speed
- Input "Press y for yes, let's do 10000 factorial test, takes quite a bit of time (3.25 mins) "; fact$
- fact$ = "1"
- ' save it
- Close #1
- Close #1
- Print "Comparing fact$ to reference fact$:"
- Input "Mismatch! Continue? y for yes "; cont$
- Print "Compare finished, mismatchs already noted if any."
- Print "Can't find 10000!.txt reference file."
- Print "zzz... press any to start sqr estimating"
- Dim n$, result$
- 'remember everything is strings
- Input "Enter a number to find it's square root, just enter to quit "; n$
- result$ = sqrRoot$(n$)
- Print result$
- ' ========= String Math Procedure start here (aprox 412 LOC for copy/paste into your app) ======
- imaginary$ = "": n$ = nmbr$
- guess$ = mr$(n$, "/", "2")
- other$ = n$
- loopcnt = loopcnt + 1
- ' go past 100 matching digits for 100 digit precision
- ' try other factor for guess$ sometimes it nails answer without all digits
- lastGuess$ = guess$
- sum$ = mr$(guess$, "+", other$)
- guess$ = mr$(sum$, "/", "2")
- other$ = mr$(n$, "/", guess$)
- 'set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
- ' This is used in nInverse$ not by Mr$ because there it saves time!
- fa$ = result$: fb$ = result$
- w = i - 1
- w = w - 1
- subtr1$ = result$
- ' 2021-06-08 fix up with new mr call that decides the sign and puts the greater number first
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = result$
- Dim copys$
- i = 1: find = 0
- i = i + 1: find = 1
- ' catchy? mr$ for math regulator cop$ = " + - * / " 1 of 4 basic arithmetics
- ' Fixed so that add and subtract have signs calc'd in Mr and correct call to add or subtract made
- ' with bigger minus smaller in subtr$() call
- 'strip signs and decimals
- aSgn$ = ""
- adp = 0
- bSgn$ = ""
- bdp = 0
- 'even up the right sides of decimals if any
- dp = adp + bdp
- 'now according to signs and op$ call add$ or subtr$
- op$ = "+" ' turn this over to + op already done! below
- postOp$ = add$(ca$, cb$)
- sgn$ = aSgn$
- 'but which is first and which is 2nd and should final sign be pos or neg
- aLTb = LTE(ca$, cb$)
- postOp$ = subtr$(cb$, ca$)
- Else ' a > b so a - sgn wins - (a - b)
- postOp$ = subtr$(ca$, cb$)
- Else ' b has the - sgn
- postOp$ = subtr$(cb$, ca$)
- Else ' result is pos
- postOp$ = subtr$(ca$, cb$)
- postOp$ = mult$(ca$, cb$)
- postOp$ = divide$(ca$, cb$)
- mr$ = trim0$(postOp$) 'trim lead 0's then tack on sign
- Dim di$, ndi$
- ' aha! found a bug when d$ gets really huge 100 is no where near enough!!!!
- ' 2021-06-03 fix by adding 100 to len(d$), plus have to go a little past 100 like 200
- ndi$ = mult$(n$, di$)
- divide$ = ndi$
- ' This uses Subtr1$ is Positive Integer only!
- ' DP = Decimal places = says when to quit if don't find perfect divisor before
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr1$(r$, mult$(d$, n$)) 'r = r -d*n ' 2021-06-08 subtr1 works faster
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- Next g
- accum$ = build$
- Next dp
- mult$ = accum$
- 'this function needs TrimLead0$(s$)
- Dim ca$, cb$
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- 'need this for ninverse faster than subtr$ for sign
- Dim ca$, cb$
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LT = -1
- LT = 0
- Dim copys$
- TrimTail0$ = copys$
- i = i - 1: find = 1
- Dim cs$, si$
- cs$ = s$
- cs$ = TrimLead0$(cs$)
- cs$ = TrimTail0$(cs$)
- ' for displaying truncated numbers say to 60 digits
- Dim cNum$
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)
The test code in main code area calculates 10000! and compares it to a reference file, if found.
Here is a copy if you'd like, the 3rd line in file is a link to where I got the number for reference in
10000!.txt:
Post by: jack on June 14, 2021, 06:50:23 pm
Post by: bplus on June 14, 2021, 08:58:55 pm
BTW you mentioned you did not understand my nInverse$(), as I recall I coded it as I learned to do division in school only we are just dividing into 1 so we are always adding 0's to remainder until big enough to divide some more by denominator and find another set of remainder start digits upon which to add zeros... maybe you figured it out already.
This String Math will have to do until you or George or Luke get a full set of operations going with memory works or with decimal math segments building.
Post by: david_uwi on June 16, 2021, 02:17:18 pm
It seems obvious that you could store the digits in an array (rather than a string) which would avoid the VAL and STR$ which are slow.
Calculating the 115 Fibonacci is trivial even doing it the hard way of going through all the numbers 11235...to get to the 115 number. I've posted it before (but as I'm very proud of it) I will post it again.
Code: QB64: [Select]
Post by: bplus on June 16, 2021, 03:23:14 pm
I am always confused when calculation that gives a large number of digits is generally tackled by using strings.
It seems obvious that you could store the digits in an array (rather than a string) which would avoid the VAL and STR$ which are slow.
Calculating the 115 Fibonacci is trivial even doing it the hard way of going through all the numbers 11235...to get to the 115 number. I've posted it before (but as I'm very proud of it) I will post it again.Code: QB64: [Select]
So what do you get for first 10,000 digit Fibonacci?
I get:
[ This attachment cannot be displayed inline in 'Print Page' view ]
Post by: bplus on June 16, 2021, 03:32:00 pm
But I never claimed to be faster, just a set of routines in about 412 LOC to extend math beyond Type restrictions of QB64.
Update: for the record, String Math took 21.1692 secs to get to 47,847th term, the first at 10,000 digits.
@david_uwi also for the record we are getting Fibonacci sequence of 115 terms from inverse of STx Number:
"999999999999999999999998999999999999999999999999"
which is so much cooler than merely adding up a bunch of terms.
If you get a whole set of routines in a fair amount of LOC then I will gladly swap out String Math routines in NY minute!
If someone needs something now, here it is, slow as it may be. :)
Post by: jack on June 16, 2021, 04:42:44 pm
try the reciprocal of 999999999999999999999999999999999999999999999999999999999999999999999999999999999999999998999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
it requires about 38,709 digits and gives 432 Fibo numbers starting with 0
here's pseudo code to produce them
Code: [Select]
s$=string$(89,"9")+"8"+string(90,"9")
z$=nInverse(s$)
j=instr(z$,".")
s$=mid(z$,j+1)
j=1
for i=1 to 432
print mid$(s,j,90)
j=j+90
next
Post by: bplus on June 16, 2021, 04:46:38 pm
Confirmed:
Counting 0 as first, 432 terms found the last starts at 38792. I had to increase my number of decimals to 39000 from what I tried the first time, probably not minimum needed to find the 432 terms. 6.81 mins was the time for last run.
Post by: jack on June 16, 2021, 07:42:07 pm
Is fast!that really fast for string math, well done bplus
1.7 seconds
Post by: bplus on June 16, 2021, 08:07:40 pm
that really fast for string math, well done bplus
I wish, that was David's code I was saying his was fast. I did say later post 21 secs for String Math.
I don't think you will catch me initiating time trials with String Math :)
Post by: jack on June 17, 2021, 03:58:03 pm
I found this interesting document MULTIPLE-LENGTH DIVISION REVISITED (https://surface.syr.edu/cgi/viewcontent.cgi?article=1162&context=eecs_techreports)
Post by: George McGinn on June 17, 2021, 10:51:24 pm
@jack (Jack - I haven't forgotten about you, it is just that my finished division code isn't in the program file I have, and I am waiting to see if my friend has a copy. Either way I will send it to you tomorrow. If I have to rewrite the division code, I will at least send you the write up on how I coded it).
hi bplus
I found this interesting document MULTIPLE-LENGTH DIVISION REVISITED (https://surface.syr.edu/cgi/viewcontent.cgi?article=1162&context=eecs_techreports)
Post by: jack on June 17, 2021, 11:02:08 pm
Post by: jack on June 21, 2021, 10:12:19 am
I am still trying to get motivated to study division but as soon as I spend 1 minute reading I loose interest
anyway, in my decfloat routines I found to my disgust that if you take the reciprocal of a number consisting of a lot of 9's and then take the reciprocal of the resulting number, the convergence is very slow, for example
n$="99999999999999999999999999999999999999999999999999"
the inverse of that number is ".0000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000001"
in sci notation it's 1.00000000000000000000000000000000000000000000000001 E-50
trying to do a reciprocal on that number to get back the original is not easy as there's no way to get a good first approximation, the Newon-Raphson method will eventually converge but it takes many iterations depending on the precision used
I tried it on your math-regulator and it returns .0000000.... instead of the original number
bplus, please explain how you handle big numbers in your nInverse function
Post by: bplus on June 21, 2021, 05:47:21 pm
Post by: jack on June 21, 2021, 07:35:12 pm
the package to get are bnc and bignum, there may be things in his code to learn from, who knows?
Post by: jack on June 21, 2021, 08:19:16 pm
I extracted the routines needed to do division from bignum, and it actually works
have not cleaned it up for unnecessary constants or variables
Code: QB64: [Select]
- 'BIGNUM.BAS v0.n
- 'Sep-Dec 1996 by Marc Kummel aka Treebeard.
- 'Contact mkummel@rain.org, http://www.rain.org/~mkummel/
- ' https://web.archive.org/web/20200220020034/http://www.rain.org/~mkummel/tbvault.html
- 'Big number arithmetic routines, done with a crypto project in mind. It's
- 'an engaging task to work out these algorithms in BASIC, since we know them
- 'so well on paper. My aim is to minimize string space; then speed. Not
- 'quite "arbitrary precision" since numbers and answer must fit in BASIC
- 'string space, 64K with PDS far strings, much less for QBasic. Don't use
- 'the same string twice in one call! bMul(s$,s$,s$) should figure s=s*s, but
- 'it won't work because passed strings are modified (and restored) during the
- 'call, so use temporary strings or pass by value. See bModPower() for an
- 'example. Can be much optimized, but it works and makes sense.
- '
- '---------------------------------------------------------------------------
- 'useful globals
- 'useful shared stuff
- 'Trick to give bmem$() its own 64k segment in PDS (but not QB).
- 'Watch out for overflows or conflicts with multiple modules.
- null$ = ""
- abort$ = "<abort>"
- op$ = "+" 'default action
- digits% = 100 'digits for division etc
- bignumpath$ = null$ 'path for files (or current dir if null)
- prmcntfile$ = "BNPRMCNT.DAT" 'prime count table
- logfile$ = "BNLOG.LOG" 'log file
- 'useful constants
- cname$(pimem) = "ã": bmem$(pimem) = "3.14159265358979323846264338327"
- cname$(pi2mem) = "2ã": bmem$(pi2mem) = "6.28318530717958647692528676654"
- cname$(emem) = "e": bmem$(emem) = "2.71828182845904523536028747135"
- cname$(ln10mem) = "ln(10)": bmem$(ln10mem) = "2.30258509299404568401799145468"
- cname$(ln2mem) = "ln(2)": bmem$(ln2mem) = ".693147180559945309417232121458"
- 'screen size and window
- topline% = 1
- botline% = 25
- topview% = topline%
- botview% = botline% - 2
- 'screen buffer for ScreenSave() and ScreenRestore()
- screenbufsize% = 80 * botline% * 2 'screen size, 2 bytes per character
- screenrow% = 1 'cursor row
- 'trap ctrl-esc for emergency exit. Speed and size hog, but useful.
- 'On Key(15) GoSub EventTrap
- 'start up
- ' LoadPrimeTable 'prime count table
- ' ShowHelp 'something to look at
- '========================================================================
- n$ = "1"
- m$ = "99999999999999999999999999999999999999999999999999"
- r$ = ""
- Print r$
- m$ = r$ ' you can't use the destination variable in the source
- Print r$
- '========================================================================
- 's = |s|
- '
- 'return true if s is negative
- '
- 'return sign of number (-1 or +1)
- '
- 'Strip leading 0s and final "." (but leave something)
- '
- n% = 1
- n% = n% + 1
- 'Strip trailing 0s to "." (but leave something)
- '
- n% = n% - 1
- 'Strip s$ to whole number and base 10 integer logarithm and sign. Decimal
- 'point is implied after the first digit, and slog% counts places left or
- 'right. bLogPut() reverses the process, and bLogDp() gives info on the
- 'decimals. Tricky, but it works and simplifies dividing and multipling.
- 'eg s$ -> s$ , slog%
- ' 660 -> 66 , 2 (6.6 * 10^ 2) (or 660,2 if zeroflag%=false)
- ' 6.6 -> 66 , 0 (6.6 * 10^ 0)
- ' .066 -> 66 , -2 (6.6 * 10^-2)
- 'bDiv(), bMul(), and bSqr() use this to trim unnecessary zeros and to locate
- 'decimal point. These set zeroflag% to trim trailing zeros, but bDivIntMod()
- 'must set it false in order to figure remainder of division. A kludge.
- '
- bStripZero s$
- Case 0
- Case 1
- n% = dpt% + 1
- n% = n% + 1
- slog% = dpt% - n%
- slog% = dpt% - 2
- 'remove trailing 0's if zeroflag%
- 'Strip a number to "standard form" with no leading or trailing 0s and no
- 'final "." All routines should return all arguments in this form.
- '
- bStripZero s$
- 'Restore a number from the integer and log figured in bLogGet(). s$ is taken
- 'as a number with the decimal after first digit, and decimal is moved slog%
- 'places left or right, adding 0s as required. Called by bDiv() and bMul().
- '
- s$ = zero$
- bClean s$
- 'shift decimal n% digits (minus=left), i.e multiply/divide by 10.
- '
- bLogGet s$, slog%, sign%, false
- bLogPut s$, slog% + n%, sign%
- 's = -s
- '
- 'Take whole number and log from bLogGet() and return number of decimal
- 'places in the expanded number; OR take string and number of decimal points
- 'desired and return the log. It works both ways.
- '
- 'out = s1 / s2 using fast long-integer algorithm. s2$ must be <= 8 digits.
- 's1$ and s2$ must be stripped first, no decimals.
- '
- quotient$ = null$
- remainder& = 0
- dig% = dividend& \ divisor&
- remainder& = dividend& - dig% * divisor&
- Next i%
- 'out = s1 / s2 using character algorithm, digit by digit, slow but honest.
- 's1$ and s2$ must be stripped first, no decimals.
- '
- quotient$ = null$
- remainder$ = null$
- 'get next digit of dividend or zero$ if past end
- dvd$ = remainder$ + zero$
- 'if dividend < divisor then digit%=0 else have to calculate it.
- 'do fast compare using string operations. see bComp%()
- bStripZero dvd$
- 'divisor is bigger, so digit is 0, easy!
- dig% = 0
- remainder$ = dvd$
- 'dividend is bigger, but no more than 9 times bigger.
- 'subtract divisor until we get remainder less than divisor.
- 'time hog, average is 5 tries through j% loop. There's a better way.
- remainder$ = null$
- borrow% = 0
- n% = last2% - j%
- Next j%
- 'if remainder < divisor then exit
- bStripZero remainder$
- dvd$ = remainder$
- Next dig%
- Next i%
- 'out = s1 / s2
- '
- 'strip divisor
- t$ = s2$
- bLogGet t$, slog2%, sign2%, true
- 'divide by zero?
- 'do powers of 10 with shifts
- out$ = s1$
- 'the hard way
- 'strip all
- s2$ = t$: t$ = null$
- bLogGet s1$, slog1%, sign1%, true
- 'figure decimal point and sign of answer
- outlog% = slog1% + bLogDp(s2$, slog2%)
- 'bump digits past leading zeros and always show whole quotient
- olddigits% = digits%
- 'do it, ignore remainder
- 'clean up
- bLogPut s1$, slog1%, sign1%
- bLogPut s2$, slog2%, sign2%
- digits% = olddigits%
Post by: bplus on June 21, 2021, 09:13:43 pm
Quote
bplus, please explain how you handle big numbers in your nInverse function
@jack I did once already, in English, no code:
https://www.qb64.org/forum/index.php?topic=3984.msg133309#msg133309
Did you see that?
nInverse of string o 9's looks OK to me>
Code: QB64: [Select]
- _Title "String Math 2021-06-14" ' b+ from SM2 (2021 June) a bunch of experiments to fix and improve speeds.
- _Delay .25
- 'test new stuff
- ' This is used in nInverse$ not by Mr$ because there it saves time!
- fa$ = result$: fb$ = result$
- w = i - 1
- w = w - 1
- subtr1$ = result$
- Dim copys$
- i = 1: find = 0
- i = i + 1: find = 1
- ' catchy? mr$ for math regulator cop$ = " + - * / " 1 of 4 basic arithmetics
- ' This uses Subtr1$ is Positive Integer only!
- ' DP = Decimal places = says when to quit if don't find perfect divisor before
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr1$(r$, mult$(d$, n$)) 'r = r -d*n ' 2021-06-08 subtr1 works faster
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- Next g
- accum$ = build$
- Next dp
- mult$ = accum$
- ' LTE Less Than or Equal for 2 Big numbers in String form
- 'this function needs TrimLead0$(s$)
- Dim ca$, cb$
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- 'need this for ninverse faster than subtr$ for sign
- Dim ca$, cb$
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LT = -1
- LT = 0
- 'set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
All you guys are posting allot of interesting things for handling Big Numbers, wish I had more time to study all these wonderful ideas, soon I hope.
Post by: jack on June 21, 2021, 09:38:39 pm
BTW TreeBeard's division is pretty fast, 1/999999999999999999999998999999999999999999999999 to 2785 digits in 0.054 seconds
Post by: bplus on June 21, 2021, 09:53:48 pm
bplus, yes the string of 9's work ok but if you feedback the result of that into nInverse to get back the original number it fails
BTW TreeBeard's division is pretty fast, 1/999999999999999999999998999999999999999999999999 to 2785 digits in 0.054 seconds
nInverse only meant to work on positive Integers.
Post by: bplus on June 21, 2021, 10:18:04 pm
An inverse of a string o 9s and then divide$ through mr$ the result into 1 reversing the inverse!
BUT only show 1 or 2 places in decimal and when nInverse$ use way more than 100 Decimal places but only show first 100 so screens continue to make sense, when see ZZZ that means SLEEPing press any key...
Thusly we can run pretty impressive string of 9's.
Code: QB64: [Select]
- _Title "String Math 2021-06-14" ' b+ from SM2 (2021 June) a bunch of experiments to fix and improve speeds.
- ' June 2021 fix some old String Math procedures, better nInverse with new LT frunction, remove experimental procedures.
- ' Now with decent sqrRoot it works independent of Mr$() = Math Regulator that handles signs and decimals and calls to
- ' add$(), subtr$, mult$, divide$ (100 significant digits), add$(), subtr$, mult$ are exact!
- ' If you need higher precsion divide, I recommend use nInverse on denominator (integer)
- ' then add sign and decimal and mult$() that number with numerator to get divsion answer in higher precision than 100.
- ' (See how Mr$() handles division and just call nInverse$ with what precision you need.)
- ' The final function showDP$() is for displaying these number to a set amount of Decimal Places.
- ' The main code is sampler of tests performed with these functions.
- _Delay .25
- 'test new stuff
- invinv$ = mr$("1", "/", inv$)
- 'set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
- 'now taking 18 digits at a time Thanks Steve McNeill
- result$ = new$ + result$
- add$ = result$
- ' This is used in nInverse$ not by Mr$ because there it saves time!
- fa$ = result$: fb$ = result$
- w = i - 1
- w = w - 1
- subtr1$ = result$
- ' 2021-06-08 fix up with new mr call that decides the sign and puts the greater number first
- tenE18 = 1000000000000000000 'yes!!! no dang E's
- sign$ = ""
- 'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
- p = (m - g) * 18
- p = p - 1
- result$ = t$ + result$
- subtr$ = result$
- Dim copys$
- i = 1: find = 0
- i = i + 1: find = 1
- ' catchy? mr$ for math regulator cop$ = " + - * / " 1 of 4 basic arithmetics
- ' Fixed so that add and subtract have signs calc'd in Mr and correct call to add or subtract made
- ' with bigger minus smaller in subtr$() call
- 'strip signs and decimals
- aSgn$ = ""
- adp = 0
- bSgn$ = ""
- bdp = 0
- 'even up the right sides of decimals if any
- dp = adp + bdp
- 'now according to signs and op$ call add$ or subtr$
- op$ = "+" ' turn this over to + op already done! below
- postOp$ = add$(ca$, cb$)
- sgn$ = aSgn$
- 'but which is first and which is 2nd and should final sign be pos or neg
- aLTb = LTE(ca$, cb$)
- postOp$ = subtr$(cb$, ca$)
- Else ' a > b so a - sgn wins - (a - b)
- postOp$ = subtr$(ca$, cb$)
- Else ' b has the - sgn
- postOp$ = subtr$(cb$, ca$)
- Else ' result is pos
- postOp$ = subtr$(ca$, cb$)
- postOp$ = mult$(ca$, cb$)
- postOp$ = divide$(ca$, cb$)
- mr$ = trim0$(postOp$) 'trim lead 0's then tack on sign
- Dim di$, ndi$
- ' aha! found a bug when d$ gets really huge 100 is no where near enough!!!!
- ' 2021-06-03 fix by adding 100 to len(d$), plus have to go a little past 100 like 200
- ndi$ = mult$(n$, di$)
- divide$ = ndi$
- ' This uses Subtr1$ is Positive Integer only!
- ' DP = Decimal places = says when to quit if don't find perfect divisor before
- m$(i) = mult$(si$, n$)
- outstr$ = ""
- outstr$ = "." 'everything else n > 1 is decimal 8/17
- r$ = "10"
- outstr$ = outstr$ + "0" ' add 0 to the output string
- r$ = r$ + "0"
- outstr$ = outstr$ + d$
- r$ = subtr1$(r$, mult$(d$, n$)) 'r = r -d*n ' 2021-06-08 subtr1 works faster
- r$ = r$ + "0" 'add another place
- 'find the longer number and make it a mult of 18 to take 18 digits at a time from it
- f1$ = b$
- f1$ = a$
- build$ = "" 'line builder
- co = 0
- 'now taking 18 digits at a time Thanks Steve McNeill
- Next g
- accum$ = build$
- Next dp
- mult$ = accum$
- 'this function needs TrimLead0$(s$)
- Dim ca$, cb$
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LTE = -1
- LTE = -1
- LTE = 0
- 'need this for ninverse faster than subtr$ for sign
- Dim ca$, cb$
- ca$ = TrimLead0$(a$): cb$ = TrimLead0(b$)
- LT = -1
- LT = 0
- Dim copys$
- TrimTail0$ = copys$
- i = i - 1: find = 1
- Dim cs$, si$
- cs$ = s$
- cs$ = TrimLead0$(cs$)
- cs$ = TrimTail0$(cs$)
- ' for displaying truncated numbers say to 60 digits
- Dim cNum$
- cNum$ = num$ 'since num$ could get changed
- showDP$ = num$
- cNum$ = "0" + cNum$ ' tack on another 0 just in case 9's all the way to left
- dp = dp + 1
- i = dp + nDP
- i = i - 1
- showDP$ = trim0$(cNum$)