my-server
← Wiki

List of arbitrary-precision arithmetic software

This article lists libraries, applications, and other software which enable or support arbitrary-precision arithmetic.

Libraries

Stand-alone application software

Software that supports arbitrary precision computations:

  • bc the POSIX arbitrary-precision arithmetic language that comes standard on most Unix-like systems.
  • dc: "Desktop Calculator" arbitrary-precision RPN calculator that comes standard on most Unix-like systems.
  • KCalc, Linux based scientific calculator
  • Maxima: a computer algebra system which bignum integers are directly inherited from its implementation language Common Lisp. In addition, it supports arbitrary-precision floating-point numbers, bigfloats.
  • Maple, Mathematica, and several other computer algebra software include arbitrary-precision arithmetic. Mathematica employs GMP for approximate number computation.
  • PARI/GP, an open source computer algebra system that supports arbitrary precision.
  • Qalculate!, an open-source free software arbitrary precision calculator with autocomplete.
  • SageMath, an open-source computer algebra system
  • SymPy, a CAS
  • Symbolic Math toolbox (MATLAB)
  • Windows Calculator, since Windows 98, uses arbitrary precision for basic operations (addition, subtraction, multiplication, division) and 32 digits of precision for advanced operations (square root, transcendental functions).
  • SmartXML, a free programming language with integrated development environment (IDE) for mathematical calculations. Variables of BigNumber type can be used, or regular numbers can be converted to big numbers using conversion operator # (e.g., #2.3^2000.1). SmartXML big numbers can have up to 100,000,000 decimal digits and up to 100,000,000 whole digits.

Languages

Programming languages that support arbitrary precision computations, either built-in, or in the standard library of the language:

  • Ada: the upcoming Ada 202x revision adds the <code>Ada.Numerics.Big_Numbers.Big_Integers</code> and <code>Ada.Numerics.Big_Numbers.Big_Reals</code> packages to the standard library, providing arbitrary precision integers and real numbers.
  • Agda: the <code>BigInt</code> datatype on Epic backend implements arbitrary-precision arithmetic.
  • Common Lisp: The ANSI Common Lisp standard supports arbitrary precision integer, ratio, and complex numbers.
  • C#: <code>System.Numerics.BigInteger</code>, from .NET 5
  • ColdFusion: the built-in <code>PrecisionEvaluate()</code> function evaluates one or more string expressions, dynamically, from left to right, using BigDecimal precision arithmetic to calculate the values of arbitrary precision arithmetic expressions.
  • D: standard library module <code>std.bigint</code>
  • Dart: the built-in <code>int</code> datatype implements arbitrary-precision arithmetic.
  • Emacs Lisp: supports integers of arbitrary size, starting with Emacs 27.1.
  • Erlang: the built-in <code>Integer</code> datatype implements arbitrary-precision arithmetic.
  • Go: the standard library package <code>math/big</code> implements arbitrary-precision integers (<code>Int</code> type), rational numbers (<code>Rat</code> type), and floating-point numbers (<code>Float</code> type)
  • Guile: the built-in <code>exact</code> numbers are of arbitrary precision. Example: <code>(expt 10 100)</code> produces the expected (large) result. Exact numbers also include rationals, so <code>(/ 3 4)</code> produces <code>3/4</code>. One of the languages implemented in Guile is Scheme.
  • Haskell: the built-in <code>Integer</code> datatype implements arbitrary-precision arithmetic and the standard <code>Data.Ratio</code> module implements rational numbers.
  • Idris: the built-in <code>Integer</code> datatype implements arbitrary-precision arithmetic.
  • ISLISP: The ISO/IEC 13816:1997(E) ISLISP standard supports arbitrary precision integer numbers.
  • J: built-in extended precision
  • Java: Class (integer), Class (decimal)
  • JavaScript: as of ES2020, BigInt is supported in most browsers; the [//code.google.com/p/gwt-math/ gwt-math] library provides an interface to <code>java.math.BigDecimal</code>, and libraries such as DecimalJS, BigInt and Crunch support arbitrary-precision integers.
  • Julia: the built-in <code>BigFloat</code> and <code>BigInt</code> types provide arbitrary-precision floating point and integer arithmetic respectively.
  • newRPL: integers and floats can be of arbitrary precision (up to at least 2000 digits); maximum number of digits configurable (default 32 digits)
  • Nim: bigints and multiple GMP bindings.
  • OCaml: The Num library supports arbitrary-precision integers and rationals.
  • OpenLisp: supports arbitrary precision integer numbers.
  • Perl: The <code>bignum</code> and <code>bigrat</code> pragmas provide BigNum and BigRational support for Perl.
  • PHP: The [//php.net/manual/en/book.bc.php BC Math] module provides arbitrary precision mathematics.
  • PicoLisp: supports arbitrary precision integers.
  • Pike: the built-in <code>int</code> type will silently change from machine-native integer to arbitrary precision as soon as the value exceeds the former's capacity.
  • Prolog: ISO standard compatible Prolog systems can check the Prolog flag "bounded". Most of the major Prolog systems support arbitrary precision integer numbers.
  • Python: the built-in <code>int</code> (3.x) / <code>long</code> (2.x) integer type is of arbitrary precision. The <code>Decimal</code> class in the standard library module decimal has user definable precision and limited mathematical operations (exponentiation, square root, etc. but no trigonometric functions). The <code>Fraction</code> class in the module fractions implements rational numbers. More extensive arbitrary precision floating point arithmetic is available with the third-party "mpmath" and "bigfloat" packages.
  • Racket: the built-in <code>exact</code> numbers are of arbitrary precision. Example: <code>(expt 10 100)</code> produces the expected (large) result. Exact numbers also include rationals, so <code>(/ 3 4)</code> produces <code>3/4</code>. Arbitrary precision floating point numbers are included in the standard library math/bigfloat module.
  • Raku: Rakudo supports [//doc.perl6.org/type/Int <code>Int</code>] and [//doc.perl6.org/type/FatRat <code>FatRat</code>] data types that promote to arbitrary-precision integers and rationals.
  • Rexx: variants including Open Object Rexx and NetRexx
  • RPL (only on HP 49/50 series in exact mode): calculator treats numbers entered without decimal point as integers rather than floats; integers are of arbitrary precision only limited by the available memory.
  • Ruby: the built-in <code>Bignum</code> integer type is of arbitrary precision. The <code>BigDecimal</code> class in the standard library module bigdecimal has user definable precision.
  • Scheme: R<sup>5</sup>RS encourages, and R<sup>6</sup>RS requires, that exact integers and exact rationals be of arbitrary precision.
  • Scala: <code>Class BigInt</code> and <code>Class BigDecimal</code>.
  • Seed7: <code>bigInteger</code> and <code>bigRational</code>.
  • Self: arbitrary precision integers are supported by the built-in <code>bigInt</code> type.
  • Smalltalk: variants including Squeak, Smalltalk/X, GNU Smalltalk, Dolphin Smalltalk, etc.
  • SmartXML, a free programming language with integrated development environment (IDE) for mathematical calculations. Variables of <code>BigNumber</code> type can be used, or regular numbers can be converted to big numbers using conversion operator <code>#</code> (e.g., <code>#2.3^2000.1</code>). SmartXML big numbers can have up to 100,000,000 decimal digits and up to 100,000,000 whole digits.
  • Standard ML: The optional built-in <code>IntInf</code> structure implements the INTEGER signature and supports arbitrary-precision integers.
  • Tcl: As of version 8.5 (2007), integers are arbitrary-precision by default. (Behind the scenes, the language switches to using an arbitrary-precision internal representation for integers too large to fit in a machine word. Bindings from C should use library functions such as <code>Tcl_GetLongFromObj</code> to get values as C-native data types from Tcl integers.)
  • Wolfram Language, like Mathematica, employs GMP for approximate number computation.

Online calculators

For one-off calculations. Runs on server or in browser. No installation or compilation required.

  • 1. https://www.mathsisfun.com/calculator-precision.html 200 places
  • 2. http://birrell.org/andrew/ratcalc/ arbitrary; select rational or fixed-point and number of places
  • 3. PARI/GP online calculator - https://pari.math.u-bordeaux.fr/gp.html (PARI/GP is a widely used computer algebra system designed for fast computations in number theory (factorizations, algebraic number theory, elliptic curves, modular forms, L functions...), but also contains a large number of other useful functions to compute with mathematical entities such as matrices, polynomials, power series, algebraic numbers etc., and a lot of transcendental functions. PARI is also available as a C library to allow for faster computations.)
  • 4.1. AutoCalcs - allow users to Search, Create, Store and Share multi-step calculations using explicit expressions featuring automated Unit Conversion. It is a platform that allows users to go beyond unit conversion, which in turn brings in significantly improved efficiency. A lot of sample calculations can be found at AutoCalcs Docs site. Calculations created with AutoCalcs can be embedded into 3rd party websites.
  • 4.2. AutoCalcs Docs - considering above mentioned AutoCalcs as the calculation engine, this Docs site is a library with a host of calculations, where each calculation is essentially a web app that can run online, be further customized, and much more. Imaging reading a book with a lot of calculations, then this is the book/manual with all calculations that can be used on the fly. It is worthwhile to mention - when units are involved in the calculations, the unit conversion can be automated.
  • 5. Big Number Calculator: an arbitrary precision integer and decimal calculator, with support for decimal shifting and data type fitting.

References