Arbitrary-precision integers (included): Difference between revisions

(→‎{{header|Raku}}: use regex)
Tag: Made through Tor
(19 intermediate revisions by 8 users not shown)
Line 1,025:
=={{header|Fōrmulæ}}==
 
{{FormulaeEntry|page=https://formulae.org/?script=examples/Arbitrary-precision_integers_%28included%29}}
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.
 
'''Solution'''
Programs in Fōrmulæ are created/edited online in its [https://formulae.org website], However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.
 
In the following script, the result is converted to a string, in order to calculate its size, and its first/last digits.
In '''[https://formulae.org/?example=Arbitrary-precision_integers_%28included%29 this]''' page you can see the program(s) related to this task and their results.
 
[[File:Fōrmulæ - Arbitrary-precision integers (included) 01.png]]
 
[[File:Fōrmulæ - Arbitrary-precision integers (included) 02.png]]
 
=={{header|GAP}}==
Line 1,196 ⟶ 1,200:
"62060698786608744707"
julia> bigstr[end-2019:end]
"89225625991821289062592256259918212890625"</syntaxhighlight>
 
=={{header|Klong}}==
Line 1,219 ⟶ 1,223:
<pre>
5^4^3^2 = 62060698786608744707...92256259918212890625 and has 183231 digits
</pre>
 
=={{header|Lambdatalk}}==
Just using Javascript's BigInt
<syntaxhighlight lang="Scheme">
 
{def N {BI.** 5 {BI.** 4 {BI.** 3 2}}}} -> N
length: {def L {W.length {N}}} -> L = 183231
20 first digits: {W.slice 0 20 {N}} -> 62060698786608744707
20 last digits: {W.slice -20 {L} {N}} -> 92256259918212890625
 
</syntaxhighlight>
 
=={{header|langur}}==
Arbitrary precision is native in langur.
<syntaxhighlight lang="langur">val .xs = string 5 ^ 4 ^ 3 ^ 2
 
val .len = len .xs
writeln .len, " digits"
 
if .len > 39 and s2s(.xs, 1..20) == "62060698786608744707" and
s2s(.xs, .len-19 .. .len) == "92256259918212890625" {
writeln "SUCCESS"
}
</syntaxhighlight>
 
{{out}}
<pre>183231 digits
SUCCESS
</pre>
 
Line 1,934 ⟶ 1,967:
{{works with|Rakudo|2022.07}}
 
<syntaxhighlight lang="raku" line>use Test;
given [**] 5, 4, 3, 2 {
ok ~([**] 5, 4, 3, 2) ~~ /^ '62060698786608744707' <digit>* '92256259918212890625' $/,
use Test;
'5**4**3**2 has expected first and last twenty digits';</syntaxhighlight>
ok ~([**] 5, 4, 3, 2) ~~ok /^ '62060698786608744707' <digit>* '92256259918212890625' $/,
'5**4**3**2 has expected first and last twenty digits';</syntaxhighlight>
printf 'This number has %d digits', .chars;
}</syntaxhighlight>
{{out}}
<pre>ok 1 - 5**4**3**2 has expected first and last twenty digits</pre>
This number has 183231 digits</pre>
 
=={{header|REXX}}==
Line 2,134 ⟶ 2,172:
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var x = 5**(4**(3**2));
var y = x.to_s;
printf("5**4**3**2 =  %s...%s and has  %i digits\n", y.ftfirst(0,1920), y.ftlast(-20), y.len);</syntaxhighlight>
{{out}}
<pre>
Line 2,466 ⟶ 2,504:
{{libheader|Wren-fmt}}
{{libheader|Wren-big}}
<syntaxhighlight lang="ecmascriptwren">import "./fmt" for Fmt
import "./big" for BigInt
 
var p = BigInt.three.pow(BigInt.two)
Line 2,490 ⟶ 2,528:
 
pub fn main() !void {
var gpaa = try bigint.initSet(std.heap.GeneralPurposeAllocator(.{}c_allocator, 5){};
try a.pow(&a.toConst(), try std.math.powi(u32, 4, try std.math.powi(u32, 3, 2)));
const allocator = &gpa.allocator;
defer _ = gpa.deinit();
 
var a = try bigint.initSet(allocator, 5);
try a.pow(a.toConst(), try std.math.powi(u32, 4, try std.math.powi(u32, 3, 2)));
defer a.deinit();
 
var as = try a.toString(allocatorstd.heap.c_allocator, 10, false.lower);
defer allocatorstd.heap.c_allocator.free(as);
 
std.debug.print("{s}...{s}\n", .{ as[0..20], as[as.len - 20 ..] });
885

edits