Dealing with 1000 digit numbers

[Snowmachine]

Hi,
Mostly i work with Octave / Matlab but i am trying to get into python also.
Lately i have a couple problems where my numbers can't be represented in binary64 or float64 default format because they exceed the max of 1.8x10^308. Is there a common way people deal with this (without toolkits)?

Similarly i have some problems where i need more than 15 digits of precision after the decimal and sometimes this exceeds the default precision. For example if i specify "precision", 56 on [1/3] the 0.(3) repeating 3s eventualy turn into non-3s which is a digital artifact.

Any suggestions or workarounds to these problems in matlab/octave or python? (Without toolkit$?) I feel like there may be something basic I am missing because it seems like this should be straightforward.
Thanks!

 

[DrClaude]

I don't know of any way to do this in Octave or Matlab, but libraries are available for C and python:
http://mpmath.org
https://gmplib.org

 

[jedishrfu]

Julia can handle big numbers. Julia is very similar to Matlab and it’s pretty right now in data science.

https://en.m.wikipedia.org/wiki/Julia_(programming_language)

 

[phyzguy]

The python sage library can handle arbitrary precision arithmetic.

 

[Snowmachine]

Thanks for the tips guys, I'll dig into these options.

 

[Baluncore]

Lately i have a couple problems where my numbers can't be represented in binary64 or float64 default format because they exceed the max of 1.8x10^308.

If the huge absolute magnitude of the exponent is the problem, then you should consider carrying the mantissa in a float64, with the exponent as an integer in a second variable. Another technique is to represented the numbers as logarithms.

Similarly i have some problems where i need more than 15 digits of precision after the decimal and sometimes this exceeds the default precision. For example if i specify "precision", 56 on [1/3] the 0.(3) repeating 3s eventualy turn into non-3s which is a digital artifact.

If each number is represented by a fraction, the ratio of two integers, then the implicit division that generates the artefact does not have to be executed until human readable output requires long division. You will get good at fraction arithmetic. You may need to apply Euclid's algorithm to simplify the fractions.

Both problems can also be solved by writing an arithmetic package that processes strings of numeric characters. Maybe keep the position of the decimal points in signed integer variables. There are many digit-by-digit computational methods available. You will get to revisit long multiplication, division and root extraction as used by the great human computers of the past.

If you really need speed, or have numbers with more than 10k digits, you should go for the gmp lib, rather than numeric strings.