Integer roots: Difference between revisions

{{trans|D}}

I b < 2 {R b}

V n1 = n - 1

print(‘3rd root of 8 = ’iRoot(8, 3))

print(‘3rd root of 9 = ’iRoot(9, 3))

{{out}}

{{trans|D}}

if b<2 -> return b

print ["3rd root of 8:" iroot 8 3]

print ["3rd root of 9:" iroot 9 3]

{{out}}

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

for nr = floor(sqr(x)) to 1 step -1

if (nr ^ n) <= x then return nr

print root(4, 167)

print root(2, 2e18)

{{out}}

<pre>

=={{header|C}}==

{{trans|C++}}

#include <math.h>

return 0;

{{out}}

<pre>3rd root of 8 = 2

=={{header|C sharp|C#}}==

{{trans|Java}}

using System.Numerics;

}

}

{{out}}

<pre>3rd integer root of 8 = 2

=={{header|C++}}==

#include <math.h>

return 0;

{{out}}

<pre>3rd root of 8 = 2

=={{header|D}}==

{{trans|Kotlin}}

import std.stdio;

b = BigInt(100)^^2000*2;

writeln("First 2001 digits of the square root of 2: ", b.iRoot(2));

{{out}}

<pre>3rd root of 8 = 2

=={{header|Elixir}}==

{{trans|Ruby}}

def root(_, b) when b<2, do: b

def root(a, b) do

end

{{out}}

=={{header|F_Sharp|F#}}==

{{trans|C#}}

let iroot (base_ : bigint) n =

Console.WriteLine("First 2001 digits of the sqaure root of 2: {0}", (iroot b 2))

{{out}}

<pre>3rd integer root of 8 = 2

=={{header|Factor}}==

{{trans|Sidef}}

prettyprint sequences ;

"First 2,001 digits of the square root of two:" print

{{out}}

<pre>

=={{header|FreeBASIC}}==

{{trans|Ring}}

Function root(n As Uinteger, x As Uinteger) As Uinteger

Print root(2, 2e18)

{{out}}

<pre>2

=={{header|Go}}==

===int===

import "fmt"

r += Δr

}

{{out}}

<pre>

</pre>

===big.Int===

import (

r.Add(r, &Δr)

}

{{out}}

<pre>

=={{header|Haskell}}==

{{trans|Python}}

root a b = findAns $ iterate (\x -> (a1 * x + b `div` (x ^ a1)) `div` a) 1

where

print $ root 3 8

print $ root 3 9

Or equivalently, in terms of an applicative expression:

integerRoot n x =

go $ iterate ((`div` n) . ((+) . (pn *) <*> (x `div`) . (^ pn))) 1

main :: IO ()

{{out}}

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.

2 <.@%: (2*10x^2*2000)

114869835499703500679862694677792758944385088909779750551371111849360320625351305681147311301150847391457571782825280872990018972855371267615994917020637676959403854539263226492033301322122190625130645468320078386350285806907949085127708283982797043969640382563667945344431106523789654147255972578315704103326302050272017414235255993151553782375173884359786924137881735354092890268530342009402133755822717151679559278360263800840317501093689917495888199116488588871447782240220513546797235647742625493141141704109917646404017146978939243424915943739448283626010758721504375406023613552985026793701507511351368254645700768390780390334017990233124030682358360249760098999315658413563173197024899154512108923313999675829872581317721346549115423634135836394159076400636688679216398175376716152621781331348

7 <.@%: (2*10x^2*2002)

=={{header|Java}}==

{{trans|Kotlin}}

public class IntegerRoots {

System.out.println(iRoot(b, 2));

}

{{out}}

<pre>3rd integer root of 8 = 2

'''Works with gojq, the Go implementation of jq'''

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

# The task:

"First 2,001 digits of the square root of two:",

{{out}}

Exactly as for [[#Julia|Julia]].

{{trans|Python}}

b < 2 && return b

a1, c = a - 1, 1

end

{{out}}

=={{header|Kotlin}}==

{{trans|Python}}

import java.math.BigInteger

println("First 2001 digits of the square root of 2:")

println(b.iRoot(2))

{{out}}

=={{header|Lua}}==

{{trans|C}}

if base < 2 then return base end

if n == 0 then return 1 end

print("3rd root of 8 = " .. root(8, 3))

print("3rd root of 9 = " .. root(9, 3))

{{out}}

<pre>3rd root of 8 = 2

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,ReadChar;

ReadChar

=={{header|Nim}}==

{{trans|Kotlin}}

{{libheader|bignum}}

proc root(x: Int; n: int): Int =

echo "First 2001 digits of the square root of 2:"

let s = $x.root(2)

{{out}}

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

sqrtnint(9,3)

{{out}}

<pre>%1 = 2

=={{header|Perl}}==

{{trans|Ruby}}

sub integer_root {

print integer_root( 3, 8), "\n";

print integer_root( 3, 9), "\n";

{{out}}

<pre>2

===Using a module===

If using bigints, we can do this directly, which will be much faster than the method above:

print 8->babs->broot(3),"\n";

print 9->babs->broot(3),"\n";

The <code>babs</code> calls are only necessary if the input might be non-negative.

Even faster, using a module:

use ntheory "rootint";

print rootint(8,3),"\n";

print rootint(9,3),"\n";

Both generate the same output as above.

=={{header|Phix}}==

{{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>

<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>

{{out}}

<pre>

=={{header|Python}}==

if b < 2:

return b

print("First 2,001 digits of the square root of two:\n{}".format(

root(2, 2 * 100 ** 2000)

{{out}}

=={{header|Quackery}}==

{{trans|Python}}

[ stack ] is b ( --> s )

say "3rd root of 9 = " 9 3 root echo cr

say "First 2001 digits of the square root of 2: "

{{out}}

(formerly Perl 6)

{{trans|Python}}

my Int $d = $p - 1;

my $guess = 10**($n.chars div $p);

}

{{out}}

<pre>141421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157273501384623091229702492483605585073721264412149709993583141322266592750559275579995050115278206057147010955997160597027453459686201472851741864088919860955232923048430871432145083976260362799525140798968725339654633180882964062061525835239505474575028775996172983557522033753185701135437460340849884716038689997069900481503054402779031645424782306849293691862158057846311159666871301301561856898723723528850926486124949771542183342042856860601468247207714358548741556570696776537202264854470158588016207584749226572260020855844665214583988939443709265918003113882464681570826301005948587040031864803421948972782906410450726368813137398552561173220402450912277002269411275736272804957381089675040183698683684507257993647290607629969413804756548237289971803268024744206292691248590521810044598421505911202494413417285314781058036033710773091828693147101711116839165817268894197587165821521282295184884720896946338628915628827659526351405422676532396946175112916024087155101351504553812875600526314680171274026539694702403005174953188629256313851881634780015693691768818523786840522878376293892143006558695686859645951555016447245098368960368873231143894155766510408839142923381132060524336294853170499157717562285497414389991880217624309652065642118273167262575395947172559346372386322614827426222086711558395999265211762526989175409881593486400834570851814722318142040704265090565323333984364578657967965192672923998753666172159825788602633636178274959942194037777536814262177387991945513972312740668983299898953867288228563786977496625199665835257761989393228453447356947949629521688914854925389047558288345260965240965428893945386466257449275563819644103169798330618520193793849400571563337205480685405758679996701213722394758214263065851322174088323829472876173936474678374319600015921888073478576172522118674904249773669292073110963697216089337086611567345853348332952546758516447107578486024636008

<br>multiply the guess ['''G'''] by unity, &nbsp; and no need to compute the guess to the 1^st power, &nbsp; bypassing some trivial arithmetic).

===integer result only===

parse arg num root digs . /*obtain the optional arguments from CL*/

if num=='' | num=="," then num= 2 /*Not specified? Then use the default.*/

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

'''output''' &nbsp; when the defaults are being used:

<pre>

===true results===

<br>Negative and complex roots are supported. &nbsp; The expressed root may have a decimal point.

parse arg num root digs . /*obtain the optional arguments from CL*/

if num=='' | num=="," then num= 2 /*Not specified? Then use the default.*/

numeric digits od /*set numeric digits to the original.*/

if oy<0 then return (1/_)i /*Is the root negative? Use reciprocal*/

'''output''' &nbsp; when the defaults are being used:

<pre>

=={{header|Ring}}==

# Project : Integer roots

ok

next

Output:

<pre>

=={{header|Ruby}}==

{{trans|Python, zkl}}

return b if b<2

a1, c = a-1, 1

puts "First 2,001 digits of the square root of two:"

puts root(2, 2*100**2000)

{{out}}<pre>First 2,001 digits of the square root of two:

14142135623730950488016887242096(...)46758516447107578486024636008</pre>

=={{header|Rust}}==

The rug crate provides the functionality required for this task.

// rug = "1.9"

let s = Integer::from(x.root(3)).to_string();

println!("First {} digits of the cube root of 2:\n{}", s.len(), shorten(&s, 70));

{{out}}

=={{header|Scala}}==

===Functional solution, tail recursive, no immutables===

object IntegerRoots extends App {

}

{{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}}

(define // quotient)

(define (y a a1 b c d e)

(display "First 2,001 digits of the cube root of two:\n")

{{out}}

=={{header|Sidef}}==

{{trans|Ruby}}

b < 2 && return(b)

var (a1, c) = (a-1, 1)

say "First 2,001 digits of the square root of two:"

{{out}}

<pre>

On the other hand, everything is very straightforward, no libraries necessary.

proc root {this n} {

if {$this < 2} {return $this}

puts [root 9 3]

puts [root [expr 2* (100**2000)] 2]

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{libheader|System.Numerics}}

Imports System.Numerics

Imports Microsoft.VisualBasic.Strings

End Module

{{out}}

<pre style="height:64ex;overflow:scroll">

=={{header|Wren}}==

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.

if (!(x is Num && x.isInteger && x >= 0)) {

Fiber.abort("First argument must be a non-negative integer.")

var n = e[1]

System.print("%(x) ^ (1/%(n)) = %(intRoot.call(x, n))")

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

for nr = floor(sqr(x)) to 1 step -1

if (nr ^ n) <= x then return nr : fi

print root(3, 9)

print root(4, 167)

{{trans|Python}}

Uses GNU GMP library

fcn root(n,r){

f:='wrap(z){ (n/z.pow(r-1) + z*(r-1))/r or 1 }; //--> v or 1

while(c!=d and c!=e){ c,d,e=d,e,f(e) }

if(d<e) d else e

{{out}}

<pre>