- The UI is awesome, amazing work! However, arbitrary precision implies that there is no fixed upper limit to the number of digits - simple tests like `0.1 + 0.2 == 0.3` and `2^53 == 2^53 + 1` (both produce "false") indicates you're still using IEEE 754 double precision floats.
If "arbitrary precision" is not as important to you as "high precision", a 128 bit decimal has enough precision for 99% of real-world applications.
- Thanks for checking it out! Should have been more clear that this is actively being worked on. This is ultimately the goal, and I'm currently working on integrating `astro_float` as the base for numbers.
- That is awesome, I look forward to following the project and hopefully contributing! I became a better Rust programmer from reading your code :)
- Do you mean, the first returns false and the second returns true?
- Ah you're right, thank you for pointing it out!
In the previous version of this comment (where I was still reading it incorrectly) I added a fun fact, that the significand of an IEEE 754 double-precision float is only allocated 52 bits, but the "hidden bit trick" provides an extra bit of precision when the normalized form starts with 1.
- Rewrite it like so
> 1/10 + 2/10 == 3/10 true >
- Thanks to everyone who gave feedback!
Arbitrary precision is now supported in 0.3.0 after integrating the `astro_float` (https://docs.rs/astro-float/latest/astro_float/index.html) `BigFloat` type as the base for numbers in the language.
Still working out the kinks, but its live so give it a try!
- > sqrt(10^100)-1 -> 100000000000000000000000000000000000000000000000000
Not what I expected.
- In the readme it says it uses double precision for numbers. Also not quite whet I expected from 'arbitrary precision'.
- Hmm, yeah. It cites `bc` as prior art, which is quite widely used; but another interesting arbitrary-precision calculator is spigot https://www.chiark.greenend.org.uk/~sgtatham/spigot/spigot.h...
- Also the AOSP calculator, of course[1,2,3].
[1] https://chadnauseam.com/coding/random/calculator-app
- Ivy does big numbers (not arbitrary) but does rationals too. It's an APL subset.
https://github.com/robpike/ivy0.1 + 0.2 3/10
- the addition of astro_float fixed this.
- Hey nice! We have similar interests. I built something similar, but with way less calculator functionality than you did :D
But the main idea I was going for was real-time JIT evaluation with rendered errors (specifically learning / using cranelift JIT) - less to do with the calculator aspect.
I ended up choosing miette for errors.
https://github.com/jasonjmcghee/basic-treesitter-cranelift-j...
- I wish you well. And I clicked you a star on github. Keep up the good work.
- very cool, welcome to the small club of CLI calculator authors! before I read this I knew of frink and crag (https://raku.land/zef:librasteve/App::Crag since you ask)
Crag is built on raku so has some neat tricks up its sleeve - you can see Crag of the Day to see some in action...
hee heecrag '0.1+0.2=0.2' #True (arbitrary precision) crag '₃₆123.45' #3F.G77777 (base 36) crag 'e ** (i * π) =~= -1' #True (math symbols, complex numbers) crag '0rMCMXLIV' #1944 (Roman numerals) crag '^<௪௨ mph>' #42mph (Unicode and units) - [dead]
