List of arbitrary-precision arithmetic software

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search

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

Libraries[edit]

Package-library name Number type Language License
Boost Multiprecision Library Integers, rationals, floats, and complex C++ and backends using GMP/MPFR Boost
TTMath Integers, floats C++ BSD
GNU Multi-Precision Library (and MPFR) Integers, rationals, and floats C and C++ with bindings LGPL
CLN Integers, rationals, floats, and complex C++ GPL
ARPREC Integers, floats, and complex C++ BSD-type
MAPM, MAPM Integers, decimal and complex floats C (bindings for C++) Freeware
MPIR (mathematics software) Integers, rationals, and floats C and C++ with bindings LGPL
LibTomMath Integers C Public Domain or WTFPL (dual-licensed)
libgcrypt Integers C LGPL
OpenSSL Integers C Apache License v2
mbed TLS Integers C Apache License v2 and GPL
JScience Integers, rationals, and floats Java BSD-type
JAS Integers, rationals, and complex numbers Java LGPL
JLinAlg Decimals, rational numbers, and complex numbers Java LGPL
Apfloat Integers, rationals, floats, and complex numbers Java, C++ LGPL
MPArith Integers, rationals, floats, and complex numbers Pascal, Delphi Zlib
InfInt Integers C++ LGPL
bigz Integers, rationals C (bindings for C++) BSD-type
C++ BigInt Class Integers C++ GPL
ramp Integers Rust Apache License v2
float Floats Rust Apache License v2
fgmp Integers C Public Domain
imath Integers, rationals ANSI C MIT
hebimath Integers, rationals, naturals, floats C (C99) MIT
bsdnt Integers, naturals C BSD (2-clause)
integer-simple Integers Haskell BSD (3-clause)
bigints Integers Nim MIT
libzahl (WIP) Integers C ISC
decimal Decimals Go BSD (3-clause)
mpmath Floats and complex Python BSD

Stand-alone application software[edit]

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.
  • SageMath, an open-source computer algebra system
  • SymPy, a CAS
  • Symbolic Math toolbox (MATLAB)
  • 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.
    • The SmartXML program file editor supports code completion and most typing is replaced by code completion. Only minimal typing is required when writing a program. Other than constant values, such as 5 or 'Some Text', everything else is supported by code completion.
    • Operations with big numbers are done using operators, such as +, -, *, /, ^, etc. (e.g., (#2.3^2000.3 / #2.3^1999.3 - 1)).
    • SmartXML maintains pool of big numbers, from which big numbers are retrieved (i.e., when there are used in code), and the numbers are released back to the pool, when a big number goes out of scope. The programmer does not have to worry about retrieving or releasing big numbers, since it is done internally by SmartXML.
  • 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).

Languages[edit]

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

  • Agda: the BigInt datatype on Epic backend implements arbitrary-precision arithmetic.
  • Common Lisp: The ANSI Common Lisp standard supports arbitrary precision integer, ratio, and complex numbers.
  • C#: System.Numerics.BigInteger, from .NET Framework 4.0
  • ColdFusion: the built-in PrecisionEvaluate() 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 std.bigint
  • Dart: the built-in int datatype implements arbitrary-precision arithmetic.
  • Erlang: the built-in Integer datatype implements arbitrary-precision arithmetic.
  • Go: the standard library package math/big implements arbitrary-precision integers (Int type), rational numbers (Rat type), and floating-point numbers (Float type)
  • Guile: the built-in exact numbers are of arbitrary precision. Example: (expt 10 100) produces the expected (large) result. Exact numbers also include rationals, so (/ 3 4) produces 3/4. One of the languages implemented in Guile is Scheme.
  • Haskell: the built-in Integer datatype implements arbitrary-precision arithmetic and the standard Data.Ratio module implements rational numbers.
  • Idris: the built-in Integer 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 java.math.BigInteger (integer), Class java.math.BigDecimal (decimal)
  • JavaScript: the gwt-math library provides an interface to java.math.BigDecimal, and libraries such as BigInt and Crunch support arbitrary-precision integers.
  • Julia: the built-in "BigFloat" and "BigInt" 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 bignum and bigrat pragmas provide BigNum and BigRational support for Perl.
  • Perl6: Rakudo supports Int and FatRat data types that promote to arbitrary-precision integers and rationals.
  • PHP: The BC Math module provides arbitrary precision mathematics.
  • PicoLisp: supports arbitrary precision integers.
  • Pike: the built-in int 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 int (3.x) / long (2.x) integer type is of arbitrary precision. The Decimal class in the standard library module decimal has user definable precision and limited mathematical operations (exponentiation, square root, etc. but no trigonometric functions). The Fraction 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 exact numbers are of arbitrary precision. Example: (expt 10 100) produces the expected (large) result. Exact numbers also include rationals, so (/ 3 4) produces 3/4.
  • 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 Bignum integer type is of arbitrary precision. The BigDecimal class in the standard library module bigdecimal has user definable precision.
  • Scheme: R5RS encourages, and R6RS requires, that exact integers and exact rationals be of arbitrary precision.
  • Scala: Class BigInt and Class BigDecimal.
  • Seed7: bigInteger and bigRational.
  • Self: arbitrary precision integers are supported by the built-in bigInt type.
  • Smalltalk: variants including Squeak, Smalltalk/X, GNU Smalltalk, Dolphin Smalltalk, etc.
  • Standard ML: The optional built-in IntInf structure implements the INTEGER signature and supports arbitrary-precision integers.
  • Wolfram Language, like Mathematica, employs GMP for approximate number computation.
  • 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.

Online calculators[edit]

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