Arbitrary-precision integers (included): Difference between revisions

{{trans|Python}}

 

print(‘5^4^3^2 = #....#. and has #. digits’.format(y[0.<20], y[(len)-20..], y.len))</syntaxhighlight>

 

 

=={{header|8th}}==

200000 n#

5 4 3 2 bfloat ^ ^ ^

 

=={{header|ACL2}}==

 

(include-book "arithmetic-3/floor-mod/floor-mod" :dir :system)

=={{header|Ada}}==

{{libheader|GMP}} Using GMP, Ada bindings provided in GNATColl

with GNATCOLL.GMP; use GNATCOLL.GMP;

with GNATCOLL.GMP.Integers; use GNATCOLL.GMP.Integers;

 

=={{header|ALGOL 68}}==

BEGIN

COMMENT

 

=={{header|Alore}}==

var len as Int

var result as Str

=={{header|Arturo}}==

 

 

print [first.n: 20 num ".." last.n: 20 num "=>" size num "digits"]</syntaxhighlight>

 

=={{header|bc}}==

 

y = 5 ^ 4 ^ 3 ^ 2

0m24.81s real 0m24.81s user 0m0.00s system</pre>

 

 

=={{header|Bracmat}}==

At the prompt type the following one-liner:

{!} 62060698786608744707...92256259918212890625

length 183231

=={{header|C}}==

=== {{libheader|GMP}} ===

#include <stdio.h>

#include <string.h>

==={{libheader|OpenSSL}}===

OpenSSL is about 17 times slower than GMP (on one computer), but still fast enough for this small task.

 

#include <openssl/bn.h> /* BN_*() */

<code>System.Numerics.BigInteger</code> was added in C# 4. The exponent of <code>BigInteger.Pow()</code> is limited to a 32-bit signed integer, which is not a problem in this specific task.

{{works with|C sharp|C#|4+}}

using System.Diagnostics;

using System.Linq;

=== {{libheader|Boost-Multiprecision (GMP Backend)}} ===

To compile link with GMP <code>-lgmp</code>

#include <boost/multiprecision/gmp.hpp>

#include <string>

=={{header|Ceylon}}==

Be sure to import ceylon.whole in your module.ceylon file.

wholeNumber,

two

 

=={{header|Clojure}}==

 

(def big (->> 2 (exp 3) (exp 4) (exp 5)))

<pre>output> 62060698786608744707..92256259918212890625 (183231 digits)</pre>

Redefining ''exp'' as follows speeds up the calculation of ''big'' about a hundred times:

(cond

(zero? (mod k 2)) (recur (* n n) (/ k 2))

with the reference implementation.

 

% Get bigint versions of 5, 4, 3 and 2

five: bigint := bigint$i2bi(5)

{{works with|GnuCOBOL}}

{{libheader|GMP}}

program-id. arbitrary-precision-integers.

remarks. Uses opaque libgmp internals that are built into libcob.

=={{header|Common Lisp}}==

Common Lisp has arbitrary precision integers, inherited from MacLisp: "[B]ignums—arbitrary precision integer arithmetic—were added [to MacLisp] in 1970 or 1971 to meet the needs of Macsyma users." [''Evolution of Lisp'' [http://dreamsongs.com/Files/Hopl2.pdf], 2.2.2]

(format t "~a...~a, length ~a" (subseq s 0 20)

(subseq s (- (length s) 20)) (length s)))</syntaxhighlight>

 

=={{header|D}}==

import std.stdio, std.bigint, std.conv;

 

=={{header|Dart}}==

Originally Dart's integral type '''int''' supported arbitrary length integers, but this is no longer the case; Dart now supports integral type '''BigInt'''.

 

int fallingPowers(int base) =>

=={{header|dc}}==

{{trans|bc}}

 

5 4 3 2 ^ ^ ^ sy [y = 5 ^ 4 ^ 3 ^ 2]sz

{{libheader| System.SysUtils}}

{{libheader| Velthuis.BigIntegers}}Thanks for Rudy Velthuis, BigIntegers Library [https://github.com/rvelthuis/DelphiBigNumbers].

program Arbitrary_precision_integers;

 

=={{header|E}}==

E implementations are required to support arbitrary-size integers transparently.

? def decimal := value.toString(10); null

? decimal(0, 20)

 

=={{header|EchoLisp}}==

;; to save space and time, we do'nt stringify Ω = 5^4^3^2 ,

;; but directly extract tail and head and number of decimal digits

=={{header|Elixir}}==

{{trans|Erlang}}

def pow(_,0), do: 1

def pow(b,e) when e > 0, do: pow(b,e,1)

As of Emacs 27.1, bignums are supported via GMP. However, there is a configurable limit on the maximum bignum size. If the limit is exceeded, an overflow error is raised.

 

(answer (number-to-string (expt 5 (expt 4 (expt 3 2)))))

(length (length answer)))

 

{{libheader|Calc}}

(length (length answer)))

(message "%s has %d digits"

 

Erlang supports arbitrary precision integers. However, the math:pow function returns a float. This implementation includes an implementation of pow for integers with exponent greater than 0.

-module(arbitrary).

-compile([export_all]).

* bigint does not support raising to a power of a bigint

* The int type does not support the power method

let answer = 5I **(int (4I ** (int (3I ** 2))))

let sans = answer.ToString()

=={{header|Factor}}==

Factor has built-in bignum support. Operations on integers overflow to bignums.

IN: rosettacode.bignums

 

Here is the solution:

 

 

big_digit_pointer *exp \ iteration counter

Here is a solution using David M. Smith's FM library, available [http://myweb.lmu.edu/dmsmith/fmlib.html here].

 

use fmzm

implicit none

freebasic has it's own gmp static library.

Here, a power function operates via a string and uinteger.

Dim Shared As Zstring * 100000000 outtext

 

 

Fun Fact: The drastically faster arbitrary-precision integer operations that landed in Java 8 (for much faster multiplication, exponentiation, and toString) were taken from Frink's implementation and contributed to Java. Another fun fact is that it took employees from Java 11 years to integrate the improvements.

as = "$a" // Coerce to string

println["Length=" + length[as] + ", " + left[as,20] + "..." + right[as,20]]</syntaxhighlight>

 

=={{header|GAP}}==

s := String(n);;

m := Length(s);

Using <code>math/big</code>'s

<code>[https://golang.org/pkg/math/big/#Int.Exp Int.Exp]</code>.

 

import (

 

=={{header|Golfscript}}==

`.. # Convert to string and make two copies

20<p # Print the first 20 digits

=={{header|Groovy}}==

Solution:

Test:

 

assert bigString[0..<20] == "62060698786608744707"

=={{header|Haskell}}==

Haskell comes with built-in support for arbitrary precision integers. The type of arbitrary precision integers is <tt>Integer</tt>.

main = do

let y = show (5 ^ 4 ^ 3 ^ 2)

 

=={{header|Hoon}}==

=+ big=(pow 5 (pow 4 (pow 3 2)))

=+ digits=(lent (skip <big> |=(a/* ?:(=(a '.') & |))))

 

Note: It takes far longer to convert the result to a string than it does to do the computation itself.

x := 5^4^3^2

write("done with computation")

=={{header|J}}==

J has built-in support for extended precision integers. See also [[J:Essays/Extended%20Precision%20Functions]].

Pow5432=: ^/ 5 4 3 2x NB. alternate J solution

# ": Pow5432 NB. number of digits

=={{header|Java}}==

Java library's <tt>BigInteger</tt> class provides support for arbitrary precision integers.

 

class IntegerPower {

 

BigInt is already implemented by Chrome and Firefox, but not yet by Explorer or Safari.

>>> console.log(`5**4**3**2 = ${y.slice(0,20)}...${y.slice(-20)} and has ${y.length} digits`);

5**4**3**2 = 62060698786608744707...92256259918212890625 and has 183231 digits</syntaxhighlight>

 

There is a BigInt.jq library for jq, but gojq, the Go implementation of jq, supports unbounded-precision integer arithmetic, so the output shown below is that produced by gojq.

def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);

Julia includes built-in support for arbitrary-precision arithmetic using the [http://gmplib.org/ GMP] (integer) and [http://www.mpfr.org/ GNU MPFR] (floating-point) libraries, wrapped by the built-in <code>BigInt</code> and <code>BigFloat</code> types, respectively.

 

0.017507363

=={{header|Kotlin}}==

{{trans|Java}}

 

fun main(args: Array<String>) {

=={{header|Lasso}}==

Interestingly, we have to define our own method for integer powers.

#factor <= 0

? return 0

 

Note the brackets are needed to enforce the desired order of exponentiating.

print len( a$)

print left$( a$, 20); "......"; right$( a$, 20)</syntaxhighlight>

=={{header|Lua}}==

Pure/native off-the-shelf Lua does not include support for arbitrary-precision arithmetic. However, there are a number of optional libraries that do, including several from an author of the language itself - one of which this example will use. (citing the "..''may'' be used instead" allowance)

-- since 5$=5^4$, and IEEE754 can handle 4$, this would be sufficient:

-- n = bc.pow(bc.new(5), bc.new(4^3^2))

=={{header|Maple}}==

Maple supports large integer arithmetic natively.

> n := 5^(4^(3^2)):

> length( n ); # number of digits

</syntaxhighlight>

In the Maple graphical user interface it is also possible to set things up so that only (say) the first and last 20 digits of a large integer are displayed explicitly. This is done as follows.

> interface( elisiondigitsbefore = 20, elisiondigitsafter = 20 ):

> 5^(4^(3^2)):

Mathematica can handle arbitrary precision integers on almost any size without further declarations.

To view only the first and last twenty digits:

Print[StringTake[s,20]<>"..."<>StringTake[s,-20]<>" ("<>ToString@StringLength@s<>" digits)"];</syntaxhighlight>

{{out}}

=={{header|MATLAB}}==

Using the [http://www.mathworks.com/matlabcentral/fileexchange/22725-variable-precision-integer-arithmetic Variable Precision Integer] library this task is accomplished thusly:

>> numDigits = order(answer) + 1

 

 

=={{header|Maxima}}==

/* 62060698786608744707...92256259918212890625

183231 */</syntaxhighlight>

=={{header|Nanoquery}}==

Integer values are arbitrary-precision by default in Nanoquery.

 

first20 = value.substring(0,20)

=={{header|Nemerle}}==

{{trans|C#}}

using System.Numerics;

using System.Numerics.BigInteger;

=

=={{header|NewLisp}}==

;;; No built-in big integer exponentiation

(define (exp-big x n)

=={{header|NetRexx}}==

=== Using Java's BigInteger Class ===

 

options replace format comments java crossref savelog symbols

</pre>

=== Using Java's BigDecimal Class ===

 

options replace format comments java crossref savelog symbols

==== Note ====

{{trans|REXX}}

 

options replace format comments java crossref savelog symbols

 

{{libheader|bigints}}

 

var x = 5.pow 4.pow 3.pow 2

 

=={{header|OCaml}}==

open Str

open String

 

A more readable program can be obtained using [http://forge.ocamlcore.org/projects/pa-do/ Delimited Overloading]:

let answer = Num.(5**4**3**2) in

let s = Num.(to_string answer) in

Oforth handles arbitrary precision integers :

 

 

5 4 3 2 pow pow pow >string dup left( 20 ) . dup right( 20 ) . size . </syntaxhighlight>

 

=={{header|Ol}}==

(define x (expt 5 (expt 4 (expt 3 2))))

(print

{{trans|REXX}}

 

--REXX program to show arbitrary precision integers.

numeric digits 200000

 

=={{header|Oz}}==

Pow5432 = {Pow 5 {Pow 4 {Pow 3 2}}}

S = {Int.toString Pow5432}

=={{header|PARI/GP}}==

PARI/GP natively supports integers of arbitrary size, so one could just use <code>N=5^4^3^2</code>. But this would be foolish (using a lot of unneeded memory) if the task is to get just the number of, and the first and last twenty digits. The number of and the leading digits are given as 1 + the integer part, resp. 10^(fractional part + offset), of the logarithm to base 10 (not as log(N) with N=A^B, but as B*log(A); one needs at least 20 correct decimals of the log, on 64 bit machines the default precision is 39 digits, but on 32 bit architecture one should set <code>default(realprecision,30)</code> to be on the safe side). To get the trailing digits, one would use modular exponentiation which is also built-in and very efficient even for extremely huge exponents:

[L\1+1, 10^frac(L)\10^(1-n), lift(m)] \\ where x\y = floor(x/y) but more efficient

}

 

An alternate but much slower method for counting decimal digits is <code>#Str(n)</code>. Note that <code>sizedigit</code> is not exact&mdash;in particular, it may be off by one (thus the function below).

my(s=sizedigit(x)-1);

if(x<10^s,s,s+1)

{{libheader|GMP}}

FreePascal comes with a header unit for gmp. Starting from the C program, this is a Pascal version:

 

uses

=={{header|Perl}}==

Perl's <tt>Math::BigInt</tt> core module handles big integers:

my $x = Math::BigInt->new('5') ** Math::BigInt->new('4') ** Math::BigInt->new('3') ** Math::BigInt->new('2');

my $y = "$x";

printf("5**4**3**2 = %s...%s and has %i digits\n", substr($y,0,20), substr($y,-20), length($y));</syntaxhighlight>

You can enable "transparent" big integer support by enabling the <tt>bigint</tt> pragma:

my $x = 5**4**3**2;

my $y = "$x";

<tt>Math::BigInt</tt> is very slow. Perl 5.10 was about 120 times slower than Ruby 1.9.2 (on one computer); Perl used more than one minute, but Ruby used less than one second.

{{out}}

5**4**3**2 = 62060698786608744707...92256259918212890625 and has 183231 digits

1m4.28s real 1m4.30s user 0m0.00s system</syntaxhighlight>

{{libheader|Phix/basics}}

{{libheader|Phix/mpfr}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

 

The first is the BC library.[http://us3.php.net/manual/en/book.bc.php] It represents the integers as strings, so may not be very efficient. The advantage is that it is more likely to be included with PHP.

$y = bcpow('5', bcpow('4', bcpow('3', '2')));

printf("5**4**3**2 = %s...%s and has %d digits\n", substr($y,0,20), substr($y,-20), strlen($y));

 

=={{header|Picat}}==

X = to_string(5**4**3**2),

Y = len(X),

 

=={{header|PicoLisp}}==

(prinl (head 20 L) "..." (tail 20 L))

(length L) )</syntaxhighlight>

 

=={{header|Pike}}==

> res[..19] == "62060698786608744707";

Result: 1

 

=={{header|PowerShell}}==

$BigNumber = [BigInt]::Pow( 5, [BigInt]::Pow( 4, [BigInt]::Pow( 3, 2 ) ) )

{{works with|SWI-Prolog|6.6}}

 

task(Length) :-

N is 5^4^3^2,

Query like so:

 

?- task(N).

N = 183231 ;

 

Using [http://www.purebasic.fr/english/viewtopic.php?p=309763#p309763 Decimal.pbi], e.g. the same included library as in [[Long multiplication#PureBasic]], this task is solved as below.

 

;- Declare the variables that will be used

=={{header|Python}}==

Python comes with built-in support for arbitrary precision integers. The type of arbitrary precision integers is <tt>[http://docs.python.org/library/stdtypes.html#typesnumeric long]</tt> in Python 2.x (overflowing operations on <tt>int</tt>'s are automatically converted into <tt>long</tt>'s), and <tt>[http://docs.python.org/3.1/library/stdtypes.html#typesnumeric int]</tt> in Python 3.x.

>>> print ("5**4**3**2 = %s...%s and has %i digits" % (y[:20], y[-20:], len(y)))

5**4**3**2 = 62060698786608744707...92256259918212890625 and has 183231 digits</syntaxhighlight>

=={{header|R}}==

R does not come with built-in support for arbitrary precision integers, but it can be implemented with the GMP library.

large <- pow.bigz(5, pow.bigz(4, pow.bigz(3, 2)))

largestr <- as.character(large)

 

=={{header|Racket}}==

 

(define answer (number->string (foldr expt 1 '(5 4 3 2))))

{{works with|Rakudo|2015.12}}

 

say "5**4**3**2 = {.substr: 0,20}...{.substr: *-20} and has {.chars} digits";

}</syntaxhighlight>

:::* &nbsp; ROO

:::* &nbsp; ooRexx &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; (tested by Walter Pachl)

numeric digits 200000 /*two hundred thousand decimal digits. */

 

 

===automatic setting of decimal digits===

numeric digits 5 /*just use enough digits for 1st time. */

 

Ruby comes with built-in support for arbitrary precision integers.

 

puts "5**4**3**2 = #{y[0..19]}...#{y[-20..-1]} and has #{y.length} digits"

</syntaxhighlight>

 

=={{header|Run BASIC}}==

print "Length:";len( x$)

print left$( x$, 20); "......"; right$( x$, 20)</syntaxhighlight>

This is accomplished via the `num` crate. This used to be part of the standard library, but was relegated to an external crate when Rust hit 1.0. It is still owned and maintained by members of the Rust core team and is the de-facto library for numerical generics and arbitrary precision arithmetic.

 

use num::bigint::BigUint;

use num::FromPrimitive;

 

=={{header|Sather}}==

main is

r:INTI;

=={{header|Scala}}==

Scala does not come with support for arbitrary precision integers powered to arbitrary precision integers, except if performed on a module. It can use arbitrary precision integers in other ways, including powering them to 32-bits integers.

res21: scala.math.BigInt = 92256259918212890625

 

=={{header|Scheme}}==

[http://people.csail.mit.edu/jaffer/r4rs_8.html#SEC52 R⁴RS] and [http://schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-9.html#%_sec_6.2.3 R⁵RS] encourage, and [http://www.r6rs.org/final/html/r6rs/r6rs-Z-H-6.html#node_sec_3.4 R⁶RS] requires, that exact integers be of arbitrary precision.

(define y (number->string x))

(define l (string-length y))

 

=={{header|Seed7}}==

include "bigint.s7i";

 

 

=={{header|Sidef}}==

var y = x.to_s;

printf("5**4**3**2 = %s...%s and has %i digits\n", y.ft(0,19), y.ft(-20), y.len);</syntaxhighlight>

{{incomplete|SIMPOL|Number of digits in result not given.}}

SIMPOL supports arbitrary precision integers powered to arbitrary precision integers. This is the only integer data type in SIMPOL. SIMPOL supports conversion from its integer data type to other formats when calling external library functions.

constant LAST20 "92256259918212890625"

 

 

A very simple approach:

num := (5 raisedTo: (4 raisedTo: (3 raisedTo: 2))) asString.

Transcript

digits: 183231</pre>

And a more advanced one:

num := (2 to: 5) fold: [:exp :base| base raisedTo: exp].

numstr := num asString.

 

=={{header|SPL}}==

n = #.size(t)

#.output(n," digits")

 

=={{header|Standard ML}}==

val answer = IntInf.pow (5, IntInf.toInt (IntInf.pow (4, IntInf.toInt (IntInf.pow (3, 2)))))

val s = IntInf.toString answer

=== mLite ===

mLite does not have a logarithm function so one was constructed (see fun log10)

fun

ntol (0, x) = if len x < 1 then [0] else x

Tcl supports arbitrary precision integers (and an exponentiation operator) from 8.5 onwards.

{{works with|Tcl|8.5}}

puts "5**4**3**2 has [string length $bigValue] digits"

if {[string match "62060698786608744707*92256259918212890625" $bigValue]} {

 

=={{header|TXR}}==

@(let* ((str (tostring (expt 5 4 3 2)))

(len (length str)))

 

===Usage===

decl unbounded_int x

x.set ((x.valueof 5).pow ((x.valueof 4).pow ((x.valueof 3).pow 2)))

 

There is no distinction between ordinary and arbitrary precision integers, but the binary converted decimal representation used here is more efficient than the usual binary representation in calculations that would otherwise be dominated by the conversion to decimal output.

#import nat

#import bcd

{{libheader|System.Numerics}}

Addressing the issue of the '''BigInteger.Pow()''' function having the exponent value limited to '''Int32.MaxValue''' (2147483647), here are a couple of alternative implementations using a '''BigInteger''' for the exponent.

Imports BI = System.Numerics.BigInteger

 

 

=={{header|Vlang}}==

import math

 

{{libheader|Wren-fmt}}

{{libheader|Wren-big}}

import "/big" for BigInt

 

 

=={{header|Zig}}==

const bigint = std.math.big.int.Managed;

 

=={{header|zkl}}==

Using the GNU big num library:

n:=BN(5).pow(BN(4).pow(BN(3).pow(2)));

s:=n.toString();

</pre>

 

{{omit from|AutoHotkey}}

{{omit from|Batch File}}

{{omit from|Brainf***}}

{{omit from|PostScript}}