Rosetta Code

Integer roots: Difference between revisions

Page Discussion

Integer roots (view source)

Revision as of 19:18, 20 April 2024

8,052 bytes added ,  1 month ago
m
Added Easylang
m (→‎{{header|Quackery}}: typo in stack comment)
m (Added Easylang)
 
(15 intermediate revisions by 10 users not shown)
Line 22:
{{trans|D}}
 
<langsyntaxhighlight lang="11l">F iRoot(BigInt b, Int n)
I b < 2 {R b}
V n1 = n - 1
Line 39:
print(‘3rd root of 8 = ’iRoot(8, 3))
print(‘3rd root of 9 = ’iRoot(9, 3))
print(‘First 2001 digits of the square root of 2: ’iRoot(BigInt(100) ^ 2000 * 2, 2))</langsyntaxhighlight>
 
{{out}}
Line 46:
3rd root of 9 = 2
First 2001 digits of the square root of 2: 141421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157273501384623091229702492483605585073721264412149709993583141322266592750559275579995050115278206057147010955997160597027453459686201472851741864088919860955232923048430871432145083976260362799525140798968725339654633180882964062061525835239505474575028775996172983557522033753185701135437460340849884716038689997069900481503054402779031645424782306849293691862158057846311159666871301301561856898723723528850926486124949771542183342042856860601468247207714358548741556570696776537202264854470158588016207584749226572260020855844665214583988939443709265918003113882464681570826301005948587040031864803421948972782906410450726368813137398552561173220402450912277002269411275736272804957381089675040183698683684507257993647290607629969413804756548237289971803268024744206292691248590521810044598421505911202494413417285314781058036033710773091828693147101711116839165817268894197587165821521282295184884720896946338628915628827659526351405422676532396946175112916024087155101351504553812875600526314680171274026539694702403005174953188629256313851881634780015693691768818523786840522878376293892143006558695686859645951555016447245098368960368873231143894155766510408839142923381132060524336294853170499157717562285497414389991880217624309652065642118273167262575395947172559346372386322614827426222086711558395999265211762526989175409881593486400834570851814722318142040704265090565323333984364578657967965192672923998753666172159825788602633636178274959942194037777536814262177387991945513972312740668983299898953867288228563786977496625199665835257761989393228453447356947949629521688914854925389047558288345260965240965428893945386466257449275563819644103169798330618520193793849400571563337205480685405758679996701213722394758214263065851322174088323829472876173936474678374319600015921888073478576172522118674904249773669292073110963697216089337086611567345853348332952546758516447107578486024636008
</pre>
 
=={{header|Ada}}==
<syntaxhighlight lang="ada">
-- Find integer roots
-- J. Carter 2023 Jun
 
with Ada.Text_IO;
with System;
 
procedure Integer_Roots is
type Big is mod System.Max_Binary_Modulus;
 
function Root (N : in Positive; X : in Big) return Big With Pre => N > 1;
-- Returns the largest integer R such that R ** N <= X
-- Derived from Modula-2
 
function Root (N : in Positive; X : in Big) return Big is
N1 : constant Positive := N - 1;
N2 : constant Big := Big (N);
N3 : constant Big := N2 - 1;
 
C : Big := 1;
D : Big := (N3 + X) / N2;
E : Big := (N3 * D + X / D ** N1) / N2;
begin -- Root
if X <= 1 then
return X;
end if;
 
Converge : loop
exit Converge when C = D or C = E;
 
C := D;
D := E;
E := (N3 * D + X / E ** N1) / N2;
end loop Converge;
 
return (if D < E then D else E);
end Root;
 
Large : constant Big := 2 * 10 ** 38;
-- On 64-bit platforms, recent versions of GNAT provide 128-bit integers
-- 10 ** 38 is the largest power of 10 < 2 ** 128
begin -- Integer_Roots
Ada.Text_IO.Put_Line (Item => "Cube root of 8 =" & Root (3, 8)'Image);
Ada.Text_IO.Put_Line (Item => "Cube root of 9 =" & Root (3, 9)'Image);
Ada.Text_IO.Put_Line (Item => "Square root of" & Large'Image & " =" & Root (2, Large)'Image);
end Integer_Roots;
</syntaxhighlight>
 
{{out}}
<pre>
Cube root of 8 = 2
Cube root of 9 = 2
Square root of 200000000000000000000000000000000000000 = 14142135623730950488
</pre>
 
Line 52 ⟶ 108:
{{trans|D}}
 
<langsyntaxhighlight lang="rebol">iroot: function [b n][
if b<2 -> return b
Line 72 ⟶ 128:
print ["3rd root of 8:" iroot 8 3]
print ["3rd root of 9:" iroot 9 3]
print ["First 2001 digits of the square root of 2:" iroot (100^2000)*2 2]</langsyntaxhighlight>
 
{{out}}
Line 82 ⟶ 138:
=={{header|BASIC256}}==
{{trans|FreeBASIC}}
<langsyntaxhighlight BASIC256lang="basic256">function root(n, x)
for nr = floor(sqr(x)) to 1 step -1
if (nr ^ n) <= x then return nr
Line 92 ⟶ 148:
print root(4, 167)
print root(2, 2e18)
end</langsyntaxhighlight>
{{out}}
<pre>
Line 101 ⟶ 157:
=={{header|C}}==
{{trans|C++}}
<langsyntaxhighlight Clang="c">#include <stdio.h>
#include <math.h>
 
Line 137 ⟶ 193:
 
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>3rd root of 8 = 2
Line 145 ⟶ 201:
=={{header|C sharp|C#}}==
{{trans|Java}}
<langsyntaxhighlight lang="csharp">using System;
using System.Numerics;
 
Line 180 ⟶ 236:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>3rd integer root of 8 = 2
Line 187 ⟶ 243:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <math.h>
 
Line 221 ⟶ 277:
 
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>3rd root of 8 = 2
Line 229 ⟶ 285:
=={{header|D}}==
{{trans|Kotlin}}
<langsyntaxhighlight Dlang="d">import std.bigint;
import std.stdio;
 
Line 258 ⟶ 314:
b = BigInt(100)^^2000*2;
writeln("First 2001 digits of the square root of 2: ", b.iRoot(2));
}</langsyntaxhighlight>
{{out}}
<pre>3rd root of 8 = 2
3rd root of 9 = 2
First 2001 digits of the square root of 2: 141421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157273501384623091229702492483605585073721264412149709993583141322266592750559275579995050115278206057147010955997160597027453459686201472851741864088919860955232923048430871432145083976260362799525140798968725339654633180882964062061525835239505474575028775996172983557522033753185701135437460340849884716038689997069900481503054402779031645424782306849293691862158057846311159666871301301561856898723723528850926486124949771542183342042856860601468247207714358548741556570696776537202264854470158588016207584749226572260020855844665214583988939443709265918003113882464681570826301005948587040031864803421948972782906410450726368813137398552561173220402450912277002269411275736272804957381089675040183698683684507257993647290607629969413804756548237289971803268024744206292691248590521810044598421505911202494413417285314781058036033710773091828693147101711116839165817268894197587165821521282295184884720896946338628915628827659526351405422676532396946175112916024087155101351504553812875600526314680171274026539694702403005174953188629256313851881634780015693691768818523786840522878376293892143006558695686859645951555016447245098368960368873231143894155766510408839142923381132060524336294853170499157717562285497414389991880217624309652065642118273167262575395947172559346372386322614827426222086711558395999265211762526989175409881593486400834570851814722318142040704265090565323333984364578657967965192672923998753666172159825788602633636178274959942194037777536814262177387991945513972312740668983299898953867288228563786977496625199665835257761989393228453447356947949629521688914854925389047558288345260965240965428893945386466257449275563819644103169798330618520193793849400571563337205480685405758679996701213722394758214263065851322174088323829472876173936474678374319600015921888073478576172522118674904249773669292073110963697216089337086611567345853348332952546758516447107578486024636008</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
{{trans|C++}}
 
 
<syntaxhighlight lang="Delphi">
 
 
function IntRoot(Base: int64; N: cardinal): int64;
var N1: cardinal;
var N2,N3,C: int64;
var D,E: int64;
begin
if Base < 2 then Result:=Base
else if N = 0 then Result:=1
else
begin
N1:=N - 1;
N2:=N;
N3:=N1;
C:=1;
d:=round((N3 + Base) / N2);
e:=round((N3 * D + Base / Power(D, N1)) / N2);
while (C<>D) and (C<>E) do
begin
C:=D;
D:=E;
E:=Round((N3*E + Base / Power(E, N1)) / N2);
end;
if D < E then Result:=D
else Result:=E;
end;
end;
 
 
procedure ShowIntegerRoots(Memo: TMemo);
var Base: int64;
begin
Memo.Lines.Add('3rd integer root of 8 = '+IntToStr(IntRoot(8, 3)));
Memo.Lines.Add('3rd integer root of 9 = '+IntToStr(IntRoot(9, 3)));
Base:=2000000000000000000;
Memo.Lines.Add('sqaure root of 2 = '+IntToStr(IntRoot(Base, 2)));
end;
 
 
 
</syntaxhighlight>
{{out}}
<pre>
3rd integer root of 8 = 2
3rd integer root of 9 = 2
sqaure root of 2 = 1414213562
 
Elapsed Time: 2.747 ms.
 
</pre>
 
=={{header|EasyLang}}==
{{trans|C}}
<syntaxhighlight>
func root base n .
if base < 2
return base
.
if n = 0
return 1
.
n1 = n - 1
n2 = n
n3 = n1
c = 1
d = (n3 + base) div n2
e = (n3 * d + base div pow d n1) div n2
while c <> d and c <> e
c = d
d = e
e = (n3 * e + base div pow e n1) div n2
.
if (d < e)
return d
.
return e
.
print "3rd root of 8 = " & root 8 3
print "3rd root of 9 = " & root 9 3
b = 2e18
print "2nd root of " & b & " = " & root b 2
</syntaxhighlight>
{{out}}
<pre>
3rd root of 8 = 2
3rd root of 9 = 2
2nd root of 2e+18 = 1414213562
</pre>
 
=={{header|Elixir}}==
{{trans|Ruby}}
<langsyntaxhighlight lang="elixir">defmodule Integer_roots do
def root(_, b) when b<2, do: b
def root(a, b) do
Line 291 ⟶ 443:
end
 
Integer_roots.task</langsyntaxhighlight>
 
{{out}}
Line 301 ⟶ 453:
</pre>
 
=={{header|F_Sharp|F#}}==
{{trans|C#}}
<langsyntaxhighlight lang="fsharp">open System
 
let iroot (base_ : bigint) n =
Line 333 ⟶ 485:
Console.WriteLine("First 2001 digits of the sqaure root of 2: {0}", (iroot b 2))
 
0 // return an integer exit code</langsyntaxhighlight>
{{out}}
<pre>3rd integer root of 8 = 2
Line 341 ⟶ 493:
=={{header|Factor}}==
{{trans|Sidef}}
<langsyntaxhighlight lang="factor">USING: io kernel locals math math.functions math.order
prettyprint sequences ;
 
Line 357 ⟶ 509:
 
"First 2,001 digits of the square root of two:" print
2 100 2000 ^ 2 * root .</langsyntaxhighlight>
{{out}}
<pre>
Line 367 ⟶ 519:
=={{header|FreeBASIC}}==
{{trans|Ring}}
<langsyntaxhighlight lang="freebasic">#define floor(x) ((x*2.0-0.5) Shr 1)
 
Function root(n As Uinteger, x As Uinteger) As Uinteger
Line 380 ⟶ 532:
Print root(2, 2e18)
 
Sleep</langsyntaxhighlight>
{{out}}
<pre>2
Line 386 ⟶ 538:
3
1414213562</pre>
 
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn root( n as UInt64, x as UInt64 ) as double
double nr, result = 0
for nr = fn floor( sqr(x) ) to 1 step -1
if ( nr ^ n ) <= x then result = nr : exit fn
next
end fn = result
 
print @"3rd root of 8 = "; fn root( 3, 8 )
print @"3rd root of 9 = "; fn root( 3, 9 )
print @"4th root of 167 = "; fn root( 4, 167 )
print @"2nd root of 2e+018 = "; fn root( 2, 2e+018 )
 
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
3rd root of 8 = 2
3rd root of 9 = 2
4th root of 167 = 3
2nd root of 2e+018 = 1414213562
</pre>
 
 
 
=={{header|Go}}==
===int===
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 421 ⟶ 600:
r += Δr
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 429 ⟶ 608:
</pre>
===big.Int===
<langsyntaxhighlight lang="go">package main
 
import (
Line 466 ⟶ 645:
r.Add(r, &Δr)
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 477 ⟶ 656:
=={{header|Haskell}}==
{{trans|Python}}
<langsyntaxhighlight lang="haskell">root :: Integer -> Integer -> Integer
root a b = findAns $ iterate (\x -> (a1 * x + b `div` (x ^ a1)) `div` a) 1
where
Line 489 ⟶ 668:
print $ root 3 8
print $ root 3 9
print $ root 2 (2 * 100 ^ 2000) -- first 2001 digits of the square root of 2</langsyntaxhighlight>
 
Or equivalently, in terms of an applicative expression:
 
<langsyntaxhighlight lang="haskell">integerRoot :: Integer -> Integer -> Integer
integerRoot n x =
go $ iterate ((`div` n) . ((+) . (pn *) <*> (x `div`) . (^ pn))) 1
Line 503 ⟶ 682:
main :: IO ()
main = mapM_ (print . uncurry integerRoot) [(3, 8), (3, 9), (2, 2 * 100 ^ 2000)]</langsyntaxhighlight>
 
{{out}}
Line 514 ⟶ 693:
<code><.@%:</code> satisfies this task. Left argument is the task's N, right argument is the task's X:
 
'''Note:''' DependingIf onyou '''''N'''''are looking for a decimal expansion of an integer root, one must select the proper number of digits for N, that is, ''2000'', ''2001'', ''2002'', etc..., otherwise the result will be the digits of the nth root of 20, 2000, etc...<br/>
For example, If you use "3 <.@%: (2*10x^2*200'''0''')" instead of "3 <.@%: (2*10x^2*200'''1''')", you will get an output starting with "271441761659490657151808946...", which are the first digits of the cube root of 20, not 2. This constraint is independent of the task requirements, except in an illustrative sense, so will not be developed further, here.
 
<langsyntaxhighlight Jlang="j"> 9!:37]0 4096 0 222 NB. set display truncation sufficiently high for our results
 
2 <.@%: (2*10x^2*2000)
Line 526 ⟶ 705:
114869835499703500679862694677792758944385088909779750551371111849360320625351305681147311301150847391457571782825280872990018972855371267615994917020637676959403854539263226492033301322122190625130645468320078386350285806907949085127708283982797043969640382563667945344431106523789654147255972578315704103326302050272017414235255993151553782375173884359786924137881735354092890268530342009402133755822717151679559278360263800840317501093689917495888199116488588871447782240220513546797235647742625493141141704109917646404017146978939243424915943739448283626010758721504375406023613552985026793701507511351368254645700768390780390334017990233124030682358360249760098999315658413563173197024899154512108923313999675829872581317721346549115423634135836394159076400636688679216398175376716152621781331348
7 <.@%: (2*10x^2*2002)
1104089513673812337649505387623344721325326600780124165514532464142106322880380980716598289886302005146897159065579931253969214680430855796510648058388081961639198643922155838145512343974763395078906646859029211806139421440562835192195007740110439139292223389537903767320705032063903809884944457070845279252405827307254864679671836816589429995916822424590361601902611505690284386526869351720866524568004847701822070064334667580822044823960984514550922242408608825451442062850448298384317793721518676765230683406727811327252052334859250776811047221310365241746671294399050316</langsyntaxhighlight>
 
=={{header|Java}}==
{{trans|Kotlin}}
<langsyntaxhighlight Javalang="java">import java.math.BigInteger;
 
public class IntegerRoots {
Line 568 ⟶ 747:
System.out.println(iRoot(b, 2));
}
}</langsyntaxhighlight>
{{out}}
<pre>3rd integer root of 8 = 2
Line 578 ⟶ 757:
 
'''Works with gojq, the Go implementation of jq'''
<langsyntaxhighlight lang="jq"># To take advantage of gojq's arbitrary-precision integer arithmetic:
def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);
 
Line 604 ⟶ 783:
# The task:
"First 2,001 digits of the square root of two:",
iroot(2; 2 * (100 | power(2000)))</langsyntaxhighlight>
{{out}}
Exactly as for [[#Julia|Julia]].
Line 613 ⟶ 792:
{{trans|Python}}
 
<langsyntaxhighlight lang="julia">function iroot(a, b)
b < 2 && return b
a1, c = a - 1, 1
Line 625 ⟶ 804:
end
 
println("First 2,001 digits of the square root of two:\n", iroot(2, 2 * big(100) ^ 2000))</langsyntaxhighlight>
 
{{out}}
Line 633 ⟶ 812:
=={{header|Kotlin}}==
{{trans|Python}}
<langsyntaxhighlight lang="scala">// version 1.1.2
 
import java.math.BigInteger
Line 667 ⟶ 846:
println("First 2001 digits of the square root of 2:")
println(b.iRoot(2))
}</langsyntaxhighlight>
 
{{out}}
Line 681 ⟶ 860:
=={{header|Lua}}==
{{trans|C}}
<langsyntaxhighlight lang="lua">function root(base, n)
if base < 2 then return base end
if n == 0 then return 1 end
Line 707 ⟶ 886:
print("3rd root of 8 = " .. root(8, 3))
print("3rd root of 9 = " .. root(9, 3))
print("2nd root of " .. b .. " = " .. root(b, 2))</langsyntaxhighlight>
{{out}}
<pre>3rd root of 8 = 2
Line 714 ⟶ 893:
 
=={{header|Modula-2}}==
<langsyntaxhighlight lang="modula2">MODULE IntegerRoot;
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,ReadChar;
Line 774 ⟶ 953:
 
ReadChar
END IntegerRoot.</langsyntaxhighlight>
 
=={{header|Nim}}==
{{trans|Kotlin}}
{{libheader|bignum}}
<langsyntaxhighlight Nimlang="nim">import bignum
 
proc root(x: Int; n: int): Int =
Line 802 ⟶ 981:
echo "First 2001 digits of the square root of 2:"
let s = $x.root(2)
for i in countup(0, s.high, 87): echo s.substr(i, i + 86)</langsyntaxhighlight>
 
{{out}}
Line 833 ⟶ 1,012:
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang="parigp">sqrtnint(8,3)
sqrtnint(9,3)
sqrtnint(2*100^2000,2)</langsyntaxhighlight>
{{out}}
<pre>%1 = 2
Line 843 ⟶ 1,022:
=={{header|Perl}}==
{{trans|Ruby}}
<langsyntaxhighlight lang="perl">use bigint;
 
sub integer_root {
Line 859 ⟶ 1,038:
print integer_root( 3, 8), "\n";
print integer_root( 3, 9), "\n";
print integer_root( 2, 2 * 100 ** 2000), "\n";</langsyntaxhighlight>
{{out}}
<pre>2
Line 867 ⟶ 1,046:
===Using a module===
If using bigints, we can do this directly, which will be much faster than the method above:
<langsyntaxhighlight lang="perl">use bigint;
print 8->babs->broot(3),"\n";
print 9->babs->broot(3),"\n";
print +(2*100**2000)->babs->broot(2),"\n";</langsyntaxhighlight>
 
The <code>babs</code> calls are only necessary if the input might be non-negative.
 
Even faster, using a module:
<langsyntaxhighlight lang="perl">use bigint;
use ntheory "rootint";
print rootint(8,3),"\n";
print rootint(9,3),"\n";
print rootint(2*100**2000,2),"\n";</langsyntaxhighlight>
 
Both generate the same output as above.
Line 885 ⟶ 1,064:
=={{header|Phix}}==
{{libheader|Phix/mpfr}}
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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>
Line 906 ⟶ 1,085:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"First digits of the cube root of 2: %s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)})</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 918 ⟶ 1,097:
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">def root(a, b):
if b < 2:
return b
Line 932 ⟶ 1,111:
print("First 2,001 digits of the square root of two:\n{}".format(
root(2, 2 * 100 ** 2000)
))</langsyntaxhighlight>
 
{{out}}
Line 940 ⟶ 1,119:
=={{header|Quackery}}==
{{trans|Python}}
<langsyntaxhighlight Quackerylang="quackery"> [ stack ] is a-1 ( --> s )
[ stack ] is b ( --> s )
 
Line 962 ⟶ 1,141:
say "3rd root of 9 = " 9 3 root echo cr
say "First 2001 digits of the square root of 2: "
2 100 2000 ** * 2 root echo cr</langsyntaxhighlight>
 
{{out}}
Line 978 ⟶ 1,157:
(formerly Perl 6)
{{trans|Python}}
<syntaxhighlight lang="raku" perl6line>sub integer_root ( Int $p where * >= 2, Int $n --> Int ) {
my Int $d = $p - 1;
(
my $guess = 10**($n.chars div $p);
my $iterator = { 10**( $d * $^x + $n.chars div ($^x ** $dp) ) div $p };,
my $endpoint = { ( $d * $^x + $n div ($x ** $pd) <=) div $np } ...
-> $a, $, and ($^xc + 1) **{ $p >a == $nc };
).tail(2).min;
min (+$guess, $iterator ... $endpoint)[*-1, *-2];
}
 
say integer_root( 2, 2 * 100 ** 2000 );</langsyntaxhighlight>
{{out}}
<pre>141421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157273501384623091229702492483605585073721264412149709993583141322266592750559275579995050115278206057147010955997160597027453459686201472851741864088919860955232923048430871432145083976260362799525140798968725339654633180882964062061525835239505474575028775996172983557522033753185701135437460340849884716038689997069900481503054402779031645424782306849293691862158057846311159666871301301561856898723723528850926486124949771542183342042856860601468247207714358548741556570696776537202264854470158588016207584749226572260020855844665214583988939443709265918003113882464681570826301005948587040031864803421948972782906410450726368813137398552561173220402450912277002269411275736272804957381089675040183698683684507257993647290607629969413804756548237289971803268024744206292691248590521810044598421505911202494413417285314781058036033710773091828693147101711116839165817268894197587165821521282295184884720896946338628915628827659526351405422676532396946175112916024087155101351504553812875600526314680171274026539694702403005174953188629256313851881634780015693691768818523786840522878376293892143006558695686859645951555016447245098368960368873231143894155766510408839142923381132060524336294853170499157717562285497414389991880217624309652065642118273167262575395947172559346372386322614827426222086711558395999265211762526989175409881593486400834570851814722318142040704265090565323333984364578657967965192672923998753666172159825788602633636178274959942194037777536814262177387991945513972312740668983299898953867288228563786977496625199665835257761989393228453447356947949629521688914854925389047558288345260965240965428893945386466257449275563819644103169798330618520193793849400571563337205480685405758679996701213722394758214263065851322174088323829472876173936474678374319600015921888073478576172522118674904249773669292073110963697216089337086611567345853348332952546758516447107578486024636008
Line 999 ⟶ 1,178:
<br>multiply the guess ['''G'''] by unity, &nbsp; and no need to compute the guess to the 1<sup>st</sup> power, &nbsp; bypassing some trivial arithmetic).
===integer result only===
<langsyntaxhighlight lang="rexx">/*REXX program calculates the Nth root of a number to a specified number of decimal digs*/
parse arg num root digs . /*obtain the optional arguments from CL*/
if num=='' | num=="," then num= 2 /*Not specified? Then use the default.*/
Line 1,021 ⟶ 1,200:
if m==1 then do until old==g; old=g; g=(g + z % g ) % root; end
else do until old==g; old=g; g=(g*m + z % (g**m) ) % root; end
return left(g,p) /*return the Nth root of Z to invoker.*/</langsyntaxhighlight>
'''output''' &nbsp; when the defaults are being used:
<pre>
Line 1,044 ⟶ 1,223:
===true results===
<br>Negative and complex roots are supported. &nbsp; The expressed root may have a decimal point.
<langsyntaxhighlight lang="rexx">/*REXX program calculates the Nth root of a number to a specified number of decimal digs*/
parse arg num root digs . /*obtain the optional arguments from CL*/
if num=='' | num=="," then num= 2 /*Not specified? Then use the default.*/
Line 1,078 ⟶ 1,257:
numeric digits od /*set numeric digits to the original.*/
if oy<0 then return (1/_)i /*Is the root negative? Use reciprocal*/
return (_/1)i /*return the Yth root of X to invoker.*/</langsyntaxhighlight>
'''output''' &nbsp; when the defaults are being used:
<pre>
Line 1,118 ⟶ 1,297:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
# Project : Integer roots
 
Line 1,132 ⟶ 1,311:
ok
next
</syntaxhighlight>
</lang>
Output:
<pre>
Line 1,139 ⟶ 1,318:
3
</pre>
 
=={{header|RPL}}==
{{trans|Python}}
« DUP 1 -
→ x n n1
« '''IF''' x 2 < '''THEN''' x
'''ELSE'''
« n1 OVER * x 3 PICK n1 ^ / IP + n / IP »
→ func
« 1 func EVAL func EVAL
'''WHILE''' ROT DUP2 ≠ SWAP 4 PICK ≠ AND
'''REPEAT''' func EVAL '''END'''
MIN
»
'''END'''
» » '<span style="color:blue">IROOT</span>' STO <span style="color:grey"> @ ''( x n → root ) with root^n ≤ x</span>''
 
=={{header|Ruby}}==
{{trans|Python, zkl}}
<langsyntaxhighlight lang="ruby">def root(a,b)
return b if b<2
a1, c = a-1, 1
Line 1,154 ⟶ 1,349:
puts "First 2,001 digits of the square root of two:"
puts root(2, 2*100**2000)
</syntaxhighlight>
</lang>
{{out}}<pre>First 2,001 digits of the square root of two:
14142135623730950488016887242096(...)46758516447107578486024636008</pre>
Line 1,160 ⟶ 1,355:
=={{header|Rust}}==
The rug crate provides the functionality required for this task.
<langsyntaxhighlight lang="rust">// [dependencies]
// rug = "1.9"
 
Line 1,190 ⟶ 1,385:
let s = Integer::from(x.root(3)).to_string();
println!("First {} digits of the cube root of 2:\n{}", s.len(), shorten(&s, 70));
}</langsyntaxhighlight>
 
{{out}}
Line 1,204 ⟶ 1,399:
=={{header|Scala}}==
===Functional solution, tail recursive, no immutables===
<langsyntaxhighlight Scalalang="scala">import scala.annotation.tailrec
 
object IntegerRoots extends App {
Line 1,231 ⟶ 1,426:
}
 
}</langsyntaxhighlight>
{{Out}}See it running in your browser by [https://scalafiddle.io/sf/bVwlHfa/0 ScalaFiddle (JavaScript, non JVM)] or by [https://scastie.scala-lang.org/0T93IhLVRGiYfuKpW7DTUg Scastie (JVM)].
 
=={{header|Scheme}}==
{{trans|Python}}
<langsyntaxhighlight lang="scheme">(define (root a b)
(define // quotient)
(define (y a a1 b c d e)
Line 1,251 ⟶ 1,446:
(display "First 2,001 digits of the cube root of two:\n")
(display (root 3 (* 2 (expt 1000 2000))))</langsyntaxhighlight>
 
{{out}}
Line 1,259 ⟶ 1,454:
=={{header|Sidef}}==
{{trans|Ruby}}
<langsyntaxhighlight lang="ruby">func root(a, b) {
b < 2 && return(b)
var (a1, c) = (a-1, 1)
Line 1,272 ⟶ 1,467:
 
say "First 2,001 digits of the square root of two:"
say root(2, 2 * 100**2000)</langsyntaxhighlight>
{{out}}
<pre>
Line 1,283 ⟶ 1,478:
 
On the other hand, everything is very straightforward, no libraries necessary.
<langsyntaxhighlight lang="tcl">
proc root {this n} {
if {$this < 2} {return $this}
Line 1,303 ⟶ 1,498:
puts [root 9 3]
puts [root [expr 2* (100**2000)] 2]
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,313 ⟶ 1,508:
=={{header|Visual Basic .NET}}==
{{libheader|System.Numerics}}
From the method described on [https://en.wikipedia.org/wiki/Nth_root_algorithm the Wikipedia page]. Included is an Integer Square Root function to compare results to the Integer Nth Square root function. One must choose the exponents carefully, otherwise one will obtain the digits of the nth root of 20, 200, 2000, etc..., instead of 2. For example, 4008 was chosen because it works for both ''n = 2'' and ''n = 3'', whereas 4004 was chosen for ''n = 7''<langsyntaxhighlight lang="vbnet">Imports System
Imports System.Numerics
Imports Microsoft.VisualBasic.Strings
Line 1,361 ⟶ 1,556:
 
End Module
</syntaxhighlight>
</lang>
{{out}}
<pre style="height:64ex;overflow:scroll">
Line 1,378 ⟶ 1,573:
 
=={{header|Wren}}==
<syntaxhighlight lang="wren">import "./big" for BigInt
Wren doesn't have arbitrary precision numerics and so can't do the third example in the task description. We therefore do the third C/C++ example instead.
 
<lang ecmascript>var intRoot = Fn.new { |x, n|
// only use for integers less than 2^53
var intRoot = Fn.new { |x, n|
if (!(x is Num && x.isInteger && x >= 0)) {
Fiber.abort("First argument must be a non-negative integer.")
Line 1,394 ⟶ 1,591:
var n = e[1]
System.print("%(x) ^ (1/%(n)) = %(intRoot.call(x, n))")
}
}</lang>
 
System.print("\nFirst 2001 digits of the square root of 2:")
System.print((BigInt.two * BigInt.new(100).pow(2000)).isqrt)</syntaxhighlight>
 
{{out}}
Line 1,401 ⟶ 1,601:
9 ^ (1/3) = 2
2e+18 ^ (1/2) = 1414213562
 
First 2001 digits of the square root of 2:
141421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157273501384623091229702492483605585073721264412149709993583141322266592750559275579995050115278206057147010955997160597027453459686201472851741864088919860955232923048430871432145083976260362799525140798968725339654633180882964062061525835239505474575028775996172983557522033753185701135437460340849884716038689997069900481503054402779031645424782306849293691862158057846311159666871301301561856898723723528850926486124949771542183342042856860601468247207714358548741556570696776537202264854470158588016207584749226572260020855844665214583988939443709265918003113882464681570826301005948587040031864803421948972782906410450726368813137398552561173220402450912277002269411275736272804957381089675040183698683684507257993647290607629969413804756548237289971803268024744206292691248590521810044598421505911202494413417285314781058036033710773091828693147101711116839165817268894197587165821521282295184884720896946338628915628827659526351405422676532396946175112916024087155101351504553812875600526314680171274026539694702403005174953188629256313851881634780015693691768818523786840522878376293892143006558695686859645951555016447245098368960368873231143894155766510408839142923381132060524336294853170499157717562285497414389991880217624309652065642118273167262575395947172559346372386322614827426222086711558395999265211762526989175409881593486400834570851814722318142040704265090565323333984364578657967965192672923998753666172159825788602633636178274959942194037777536814262177387991945513972312740668983299898953867288228563786977496625199665835257761989393228453447356947949629521688914854925389047558288345260965240965428893945386466257449275563819644103169798330618520193793849400571563337205480685405758679996701213722394758214263065851322174088323829472876173936474678374319600015921888073478576172522118674904249773669292073110963697216089337086611567345853348332952546758516447107578486024636008
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">func real IRoot(X, N);
real X, N;
return Floor(Pow(X, 1./N));
 
[Format(1, 0);
RlOut(0, IRoot(8., 3.)); CrLf(0);
RlOut(0, IRoot(9., 3.)); CrLf(0);
RlOut(0, IRoot(2e18, 2.)); CrLf(0);
]</syntaxhighlight>
{{out}}
<pre>
2
2
1414213562
</pre>
 
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<langsyntaxhighlight lang="yabasic">sub root(n, x)
for nr = floor(sqr(x)) to 1 step -1
if (nr ^ n) <= x then return nr : fi
Line 1,415 ⟶ 1,634:
print root(3, 9)
print root(4, 167)
end</langsyntaxhighlight>
 
 
Line 1,421 ⟶ 1,640:
{{trans|Python}}
Uses GNU GMP library
<langsyntaxhighlight lang="zkl">var [const] BN=Import("zklBigNum");
fcn root(n,r){
f:='wrap(z){ (n/z.pow(r-1) + z*(r-1))/r or 1 }; //--> v or 1
Line 1,427 ⟶ 1,646:
while(c!=d and c!=e){ c,d,e=d,e,f(e) }
if(d<e) d else e
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">a:=BN(100).pow(2000)*2;
println("Does GMP agree: ",root(a,3)==a.root(3));</langsyntaxhighlight>
{{out}}
<pre>
Chkas
2,042

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/268296...363830"