Nth root: Difference between revisions

{{trans|Nim}}

 

V result = a

V x = a / n

print(nthroot(34.0, 5))

print(nthroot(42.0, 10))

 

{{out}}

The 'include' file FORMAT, to format a floating point number, can be found in:

[[360_Assembly_include|Include files 360 Assembly]].

NTHROOT CSECT

USING NTHROOT,R13 base register

PG DC CL80' ' buffer

REGEQU

{{out}}

<pre> 1.414213</pre>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program nroot64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

 

PROC NthRoot(REAL POINTER a,n REAL POINTER res)

Test("7","0.5")

Test("12.34","56.78")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Nth_root.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

The implementation is generic and supposed to work with any floating-point type. There is no result accuracy argument of Nth_Root, because the iteration is supposed to be monotonically descending to the root when starts at ''A''. Thus it should converge when this condition gets violated, i.e. when ''x''_''k''+1''&ge;''x''_''k''''.

with Ada.Text_IO; use Ada.Text_IO;

 

Put_Line ("5642.0 125th =" & Long_Float'Image (Long_Nth_Root (5642.0, 125)));

end Test_Nth_Root;

Sample output:

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - missing transput, and missing extended precision}}

PROC nth root = (INT n, LONG REAL a, p)LONG REAL:

10 ROOT ( LONG 7131.5 ** 10 ),

5 ROOT 34))

Output:

<pre>

 

=={{header|ALGOL W}}==

% nth root algorithm %

% returns the nth root of A, A must be > 0 %

write( nthRoot( 7131.5 ** 10, 10, 1'-5 ) );

write( nthRoot( 64, 6, 1'-5 ) );

{{out}}

<pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program nroot.s */

dfPrec: .double 0f1E-10 @ précision

 

 

=={{header|Arturo}}==

{{trans|Nim}}

N: to :floating n

result: a

print nthRoot 34.0 5

print nthRoot 42.0 10

 

{{out}}

 

=={{header|AutoHotkey}}==

 

MsgBox, % nthRoot( 10, 7131.5**10, p) "`n"

}

Return, x2

Message box shows:

<pre>7131.500000

 

=={{header|AutoIt}}==

$A=4913

$n=3

EndIf

Return nth_root_rec($A,$n,((($n-1)*$x)+($A/$x^($n-1)))/$n)

output :

<pre>20

=={{header|AWK}}==

 

#!/usr/bin/awk -f

BEGIN {

return x

}

 

Sample output:

This function is fairly generic MS BASIC. It could likely be used in most modern BASICs with little or no change.

 

DIM tmp1 AS DOUBLE, tmp2 AS DOUBLE

' Initial guess:

LOOP WHILE (ABS(tmp1 - tmp2) > diffLimit)

RootX = tmp1

 

Note that for the above to work in QBasic, the function definition needs to be changed like so:

 

The function is called like so:

 

 

Sample output:

=={{header|Basic09}}==

{{Works with |OS9 operating system -- RUN nth(root,number,precision)}}

PROCEDURE nth

PARAM N : INTEGER; A, P : REAL

PRINT "The Root is: ";TEMP1

END

 

=={{header|BASIC256}}==

precision = 0.0001

 

tmp = nth_root(n, 5643)

print n; " "; tmp; chr(9); (tmp ^ n)

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

@% = &D0D

PRINT "Cube root of 5 is "; FNroot(3, 5, 0)

SWAP x0, x1

UNTIL ABS (x0 - x1) <= d

'''Output:'''

<pre>

 

=={{header|bc}}==

* 'n' must be an integer.

* Result will have 'd' digits after the decimal point.

scale = o

return(y)

 

=={{header|BQN}}==

<code>_while_</code> is a [https://mlochbaum.github.io/bqncrate/ BQNcrate] idiom used for unbounded looping here.

 

Root ← √

Root1 ← ⋆⟜÷˜

•Show 3 Root1 5

•Show 3 Root2 5

1.7099759466766968

1.7099759641072136

 

[https://mlochbaum.github.io/BQN/try.html#code=X3doaWxlXyDihpAge/CdlL3ijZ/wnZS+4oiY8J2UvV/wnZWjX/CdlL7iiJjwnZS94o2f8J2UvvCdlal9ClJvb3Qg4oaQIOKImgpSb290MSDihpAg4ouG4p+cw7fLnApSb290MiDihpAgewogIG4g8J2ViiBh4oC/cHJlYzoKICAx4oqRewogICAgcOKAv3g6CiAgICDin6gKICAgICAgeAogICAgICAoKHAgw5cgbiAtIDEpICsgYSDDtyBwIOKLhiBuIC0gMSkgw7cgbgogICAg4p+pCiAgfSBfd2hpbGVfIHsKICAgIHDigL94OgogICAgcHJlYyDiiaQgfCBwIC0geAogIH0g4p+oYSwg4oyKYcO3buKfqTsKICDwnZWoIPCdlYog8J2VqTog8J2VqCDwnZWKIPCdlanigL8xRcKvNQp9CgrigKJTaG93IDMgUm9vdCA1CuKAolNob3cgMyBSb290MSA1CuKAolNob3cgMyBSb290MiA1CuKAolNob3cgMyBSb290MiA14oC/MUXCrzE2Cgo= Try It!]

=={{header|Bracmat}}==

Bracmat does not have floating point numbers as primitive type. Instead we have to use rational numbers. This code is not fast!

= n a d x0 x1 d2 rnd 10-d

. ( rnd { For 'rounding' rational numbers = keep number of digits within bounds. }

& show$(2,2,100)

& show$(125,5642,20)

Output:

<pre>1024^(1/10)=2,00000000000000000000*10E0

=={{header|C}}==

Implemented without using math library, because if we were to use <code>pow()</code>, the whole exercise wouldn't make sense.

#include <float.h>

 

return 0;

}

 

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

Almost exactly how C works.

static void Main(string[] args)

{

return x[0];

}

 

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

 

{

double result = guess;

return result;

};

 

{

return pow(value, (double)(1 / degree));

};

 

=={{header|Clojure}}==

 

(ns test-project-intellij.core

(:gen-class))

(recur A n guess-current (+ guess-current (calc-delta A guess-current n)))))) ; iterate answer using tail recursion

 

 

=={{header|COBOL}}==

IDENTIFICATION DIVISION.

PROGRAM-ID. Nth-Root.

END-PROGRAM.

{{out}}

<pre>

=={{header|CoffeeScript}}==

 

nth_root = (A, n, precision=0.0000000000001) ->

x = 1

root = nth_root x, n

console.log "#{x} root #{n} = #{root} (root^#{n} = #{Math.pow root, n})"

output

> coffee nth_root.coffee

8 root 3 = 2 (root^3 = 8)

100 root 5 = 2.5118864315095806 (root^5 = 100.0000000000001)

100 root 10 = 1.5848931924611134 (root^10 = 99.99999999999993)

 

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

This version does not check for cycles in <var>x_i</var> and <var>x_i+1</var>, but finishes when the difference between them drops below <var>ε</var>. The initial guess can be provided, but defaults to <var>n-1</var>.

 

(assert (and (> n 1) (> a 0)))

(flet ((next (x)

(do* ((xi guess xi+1)

(xi+1 (next xi) (next xi)))

 

<code>nth-root</code> may return rationals rather than floating point numbers, so easy checking for correctness may require coercion to floats. For instance,

 

(rf (coerce r 'float)))

(print (* r r r ))

 

produces the following output.

 

=={{header|D}}==

 

real nthroot(in int n, in real A, in real p=0.001) pure nothrow {

writeln(nthroot(10, 7131.5 ^^ 10));

writeln(nthroot(6, 64));

{{out}}

<pre>7131.5

 

=={{header|Delphi}}==

USES

Math;

Result := x_p;

end;

 

=={{header|E}}==

(Disclaimer: This was not written by a numerics expert; there may be reasons this is a bad idea. Also, it might be that cycles are always of length 2, which would reduce the amount of calculation needed by 2/3.)

 

require(n > 1 && x > 0)

def np := n - 1

}

return g1

 

=={{header|EasyLang}}==

 

r = 1

for i range n

call nth_root x 10 r

numfmt 0 4

 

=={{header|Elixir}}==

{{trans|Erlang}}

def nth_root(n, x, precision \\ 1.0e-5) do

f = fn(prev) -> ((n - 1) * prev + x / :math.pow(prev, (n-1))) / n end

Enum.each([{2, 2}, {4, 81}, {10, 1024}, {1/2, 7}], fn {n, x} ->

IO.puts "#{n} root of #{x} is #{RC.nth_root(n, x)}"

 

{{out}}

=={{header|Erlang}}==

Done by finding the fixed point of a function, which aims to find a value of <var>x</var> for which <var>f(x)=x</var>:

fixed_point(F, Guess, Tolerance, F(Guess)).

fixed_point(_, Guess, Tolerance, Next) when abs(Guess - Next) < Tolerance ->

Next;

fixed_point(F, _, Tolerance, Next) ->

The nth root function algorithm defined on the wikipedia page linked above can advantage of this:

nth_root(N, X, Precision) ->

F = fun(Prev) -> ((N - 1) * Prev + X / math:pow(Prev, (N-1))) / N end,

 

=={{header|Excel}}==

 

Beside the obvious;

*Cell A1 is the base.

*Cell B1 is the exponent.

 

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

let nthroot n A =

let rec f x =

printf "%A" (nthroot n A)

0

 

Compiled using <em>fsc nthroot.fs</em> example output:<pre>

=={{header|Factor}}==

{{trans|Forth}}

 

:: th-root ( a n -- a^1/n )

 

34 5 th-root . ! 2.024397458499888

 

=={{header|Forth}}==

a

begin

 

34e 5e th-root f. \ 2.02439745849989

 

=={{header|Fortran}}==

implicit none

 

end function nthroot

 

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre> n 5643 ^ 1 / n nth_root ^ n

 

=={{header|FutureBasic}}==

 

local fn NthRoot( root as long, a as long, precision as double ) as double

print " 5th Root of 34 Precision .00001", using "#.###############"; fn NthRoot( 5, 34, 0.00001 )

 

Output:

<pre>

 

=={{header|Go}}==

n1 := n - 1

n1f, rn := float64(n1), 1/float64(n)

}

return x

 

The above version is for 64 bit wide floating point numbers. The following uses `math/big` Float to implement this same function with 256 bits of precision.

''A set of wrapper functions around the somewhat muddled big math library functions is used to make the main function more readable, and also it was necessary to create a power function (Exp) as the library also lacks this function.'' '''The exponent in the limit must be at least one less than the number of bits of precision of the input value or the function will enter an infinite loop!'''

 

import "math/big"

 

return x.Cmp(y) == -1

}

 

=={{header|Groovy}}==

Solution:

import static java.math.RoundingMode.HALF_UP

 

(xNew as BigDecimal).setScale(7, HALF_UP)

}

 

Test:

static final tolerance = 0.00001

}

it.b, it.n, r, it.r)

assert (r - it.r).abs() <= tolerance

 

Output:

 

Function exits when there's no difference between two successive values.

Use:

<pre>*Main> 2 `nthRoot` 2

Or, in applicative terms, with formatted output:

 

nthRoot n x =

fst $

rjust n c = drop . length <*> (replicate n c ++)

in unlines $

{{Out}}

<pre>Nth roots:

 

=={{header|HicEst}}==

WRITE(Messagebox) NthRoot(10, 7131.5^10)

 

 

WRITE(Messagebox, Name) 'Cannot solve problem for:', prec, n, A

 

=={{header|Icon}} and {{header|Unicon}}==

All Icon/Unicon reals are double precision.

showroot(125,3)

showroot(27,3)

end

 

 

Output:<pre>3-th root of 125 = 5.0

But, since the [[Talk:Nth_root_algorithm#Comparison_to_Non-integer_Exponentiation|talk page discourages]] using built-in facilities, here is a reimplementation, using the [[#E|E]] algorithm:

 

iter =. N %~ (NP * ]) + X % ] ^ NP

nth_root =: (, , _1+[) iter^:_ f. ]

10 nth_root 7131.5^10

 

=={{header|Java}}==

{{trans|Fortran}}

return nthroot(n, A, .001);

}

}

return x;

{{trans|E}}

assert (n > 1 && x > 0);

int np = n - 1;

private static double iter(double g, int np, int n, double x) {

return (np * g + x / Math.pow(g, np)) / n;

 

=={{header|JavaScript}}==

Gives the ''n'':nth root of ''num'', with precision ''prec''. (''n'' defaults to 2 [e.g. sqrt], ''prec'' defaults to 12.)

 

var n = nArg || 2;

var prec = precArg || 12;

return x;

 

=={{header|jq}}==

# absolute precision if "precision" > 0, or to within the precision

# allowed by IEEE 754 64-bit numbers.

else [., ., (./n), n, 0] | _iterate

end

'''Example''':

Compare the results of iterative_nth_root and nth_root implemented using builtins

def nth_root(n): log / n | exp;

def lpad(n): tostring | (n - length) * " " + .;

# 5^m for various values of n:

"5^(1/ n): builtin precision=1e-10 precision=0",

{{Out}}

5^(1/ n): builtin precision=1e-10 precision=0

5^(1/ 1): 4.999999999999999 vs 5 vs 5

5^(1/ 1000): 1.0016107337527294 vs 1.0016107337527294 vs 1.0016107337527294

5^(1/10000): 1.0001609567433902 vs 1.0001609567433902 vs 1.0001609567433902

 

=={{header|Julia}}==

Julia has a built-in exponentiation function <code>A^(1 / n)</code>, but the specification calls for us to use Newton's method (which we iterate until the limits of machine precision are reached):

 

r < 0 || n == 0 && throw(DomainError())

n < 0 && return 1 / nthroot(-n, r)

 

@show nthroot.(-5:2:5, 5.0)

 

{{out}}

=={{header|Kotlin}}==

{{trans|E}}

 

fun nthRoot(x: Double, n: Int): Double {

for (number in numbers)

println("${number.first} ^ 1/${number.second}\t = ${nthRoot(number.first, number.second)}")

 

{{out}}

=={{header|Lambdatalk}}==

Translation of Scheme

{def root

{def good-enough? {lambda {next guess tol}

{root {pow 2 10} 10 0.001}

-> 2.000047868581671

 

=={{header|langur}}==

{{works with|langur|0.8}}

{{trans|D}}

writeln( (7131.5 ^ 10) ^/ 10 )

writeln 64 ^/ 6

writeln "calculation"

writeln .nthroot(10, 7131.5 ^ 10, 0.001)

 

{{out}}

 

=={{header|Liberty BASIC}}==

print "First estimate is: ", using( "#.###############", NthRoot( 125, 5642, 0.001 ));

print " ... and better is: ", using( "#.###############", NthRoot( 125, 5642, 0.00001))

end

First estimate is: 1.071559602191682 ... and better is: 1.071547591944771

125'th root of 5642 by LB's exponentiation operator is 1.071547591944767

 

=={{header|Lingo}}==

return power(x, 1.0/root)

put nthRoot(4, 4)

 

=={{header|Logo}}==

output and [:a - :b < 1e-5] [:a - :b > -1e-5]

end

end

 

 

=={{header|Lua}}==

function nroot(root, num)

return num^(1/root)

end

 

=={{header|M2000 Interpreter}}==

 

 

Module Checkit {

Function Root (a, n%, d as double=1.e-4) {

}

Checkit

 

=={{header|Maple}}==

 

The <code>root</code> command performs this task.

root(1728, 3);

 

 

root(2.0, 2);

 

Output:

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

 

=={{header|MATLAB}}==

 

format long

end

 

 

Sample Output:

 

ans =

 

 

=={{header|Maxima}}==

[x, y, d, p: fpprec],

fpprec: p + 10,

fpprec: p,

bfloat(y)

 

=={{header|Metafont}}==

Metafont does not use IEEE floating point and we can't go beyond 0.0001 or it will loop forever.

x0 := A / n;

m := n - 1;

show 0.5 nthroot 7; % 49.00528

 

 

=={{header|МК-61/52}}==

Instruction: ''number'' ^ ''degree'' В/О С/П

 

=={{header|NetRexx}}==

{{trans|REXX}}

/*NetRexx program to calculate the Nth root of X, with DIGS accuracy. */

class nth_root

return _/1 /*normalize the number to digs. */

 

 

=={{header|NewLISP}}==

(let ((x1 a)

(x2 (div a n)))

(div a (pow x1 (- n 1))))

n)))

 

=={{header|Nim}}==

 

proc nthRoot(a: float; n: int): float =

echo nthRoot(34.0, 5)

echo nthRoot(42.0, 10)

Output:

<pre>2.024397458499885

=={{header|Objeck}}==

{{trans|C}}

function : Main(args : String[]) ~ Nil {

NthRoot(5, 34, .001)->PrintLine();

return x[1];

}

 

=={{header|OCaml}}==

{{trans|C}}

let nf = float n in let nf1 = nf -. 1.0 in

let rec iter x =

Printf.printf "%g\n" (nthroot 10 (7131.5 ** 10.0) ());

Printf.printf "%g\n" (nthroot 5 34.0 ());

 

=={{header|Octave}}==

Octave has it's how <tt>nthroot</tt> function.

r = A.^(1./n)

 

Here it is another implementation (after Tcl)

 

{{trans|Tcl}}

x0 = A / n;

m = n - 1;

x0 = x1;

endwhile

 

Here is an more elegant way by computing the successive differences in an explicit way:

r = A / n;

m = n - 1;

r+= d;

until (abs(d) < abs(r * 1e-9))

 

Show its usage and the built-in <tt>nthroot</tt> function

 

nthroot(7131.5 .^ 10, 10)

m_nthroot(5, 34)

nthroot(34, 5)

m_nthroot(0.5, 7)

 

=={{header|Oforth}}==

 

 

{{out}}

 

=={{header|Oz}}==

fun {NthRoot NInt A}

N = {Int.toFloat NInt}

end

in

 

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

 

=={{header|Pascal}}==

=={{header|Perl}}==

{{trans|Tcl}}

 

sub nthroot ($$)

$x0 = $x1;

}

 

print nthroot(10, 7131.5 ** 10), "\n";

 

=={{header|Phix}}==

Main loop copied from AWK, and as per C uses pow_() instead of power() since using the latter would make the whole exercise somewhat pointless.

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

<span style="color: #008080;">function</span> <span style="color: #000000;">pow_</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">e</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">1024</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">27</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">5642</span><span style="color: #0000FF;">,</span><span style="color: #000000;">125</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">4913</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">16</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">16</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">125</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">1000000000</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">1000000000</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">}},</span><span style="color: #000000;">test</span><span style="color: #0000FF;">)</span>

Note that a {7,0.5} test would need to use power() instead of pow_().

{{out}}

 

=={{header|Phixmonti}}==

var n var y

1e-15 var eps /# relative accuracy #/

"The " e "th root of " b " is " b 1 e / power " (" b e nthroot ")" 9 tolist

printList drop nl

 

=={{header|PHP}}==

{

$x[0] = $number;

}

return $x[1];

 

=={{header|Picat}}==

L = [[2,2],

[34,5],

X0 := X1,

X1 := (1.0 / NF)*((NF - 1.0)*X0 + (A / (X0 ** (NF - 1))))

 

{{out}}

 

=={{header|PicoLisp}}==

 

(de nthRoot (N A)

(prinl (format (nthRoot 2 2.0) *Scl))

(prinl (format (nthRoot 3 12.3) *Scl))

Output:

<pre>1.414214

 

=={{header|PL/I}}==

root: procedure (A, N) returns (float);

declare A float, N fixed binary;

end;

return (xi);

Results:

<pre>

=={{header|PowerShell}}==

This sample implementation does not use <code>[System.Math]</code> classes.

# Thus, if there are errors the 'scary' red-text

# error messages will appear.

 

((root 5 2)+1)/2 #Extra: Computes the golden ratio

{{Out}}

<pre>PS> .\NTH.PS1

=={{header|Prolog}}==

Uses integer math, though via scaling, it can approximate non-integral roots to arbitrary precision.

iroot(_, 0, 0) :- !.

iroot(M, N, R) :-

newton(2, A, X0, X1) :- X1 is (X0 + A div X0) >> 1, !. % fast special case

newton(N, A, X0, X1) :- X1 is ((N - 1)*X0 + A div X0**(N - 1)) div N.

{{Out}}

<pre>

 

=={{header|PureBasic}}==

 

Procedure.d Nth_root(n.i, A.d, p.d=#Def_p)

Debug Nth_root(125,5642)

Debug "And better:"

'''Outputs

125'th root of 5642 is

 

=={{header|Python}}==

 

def nthroot (n, A, precision):

x_0, x_1 = x_1, (1 / n)*((n - 1)*x_0 + (A / (x_0 ** (n - 1))))

if x_0 == x_1:

 

print nthroot(10,42, 20)

 

Or, in terms of a general '''until''' function:

{{Works with|Python|3.7}}

 

from decimal import Decimal, getcontext

 

if __name__ == '__main__':

{{Out}}

<pre>Nth roots at various precisions:

 

=={{header|R}}==

{

ifelse(A < 1, x0 <- A * n, x0 <- A / n)

}

nthroot(7131.5^10, 10) # 7131.5

 

=={{header|Racket}}==

 

(define (nth-root number root (tolerance 0.001))

next-guess

(loop next-guess)))

 

=={{header|Raku}}==

(formerly Perl 6)

 

{

my $x0 = $A / $n;

}

 

 

=={{header|RATFOR}}==

program nth

#

 

end

<pre>

 

 

=={{header|REXX}}==

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

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

if \complex then g=g*sign(Ox) /*adjust the sign (maybe). */

numeric digits oDigs /*reinstate the original digits. */

'''output''' &nbsp; when using the default inputs:

<pre>

 

=={{header|Ring}}==

decimals(12)

see "cube root of 5 is : " + root(3, 5, 0) + nl

end

return x

Output:

<pre>

 

=={{header|Ruby}}==

x = Float(a)

begin

end

 

 

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

print "125th Root of 5643 Precision .001 ";using( "#.###############", NthRoot( 125, 5642, 0.001 ))

print "125th Root of 5643 Precision .00001 ";using( "#.###############", NthRoot( 125, 5642, 0.00001))

end function

<pre>125th Root of 5643 Precision .001 1.071559602456735

125th Root of 5643 Precision .00001 1.071547591944771

=={{header|Rust}}==

{{trans|Raku}}

 

fn nthRoot(n: f64, A: f64) -> f64 {

fn main() {

println!("{}", nthRoot(3. , 8. ));

 

=={{header|Sather}}==

{{trans|Octave}}

nthroot(n:INT, a:FLT):FLT

pre n > 0

end;

 

 

main is

a:FLT := 2.5 ^ 10.0;

#OUT + MATH::nthroot(10, a) + "\n";

end;

 

=={{header|S-BASIC}}==

seems unnecessarily cumbersome, given the ready availability of S-BASIC's built-in exp and

natural log functions.

rem - return nth root of x

function nthroot(x, n = real) = real

 

end

But if the six or seven digits supported by S-BASIC's single-precision REAL data type is insufficient, Newton's Method is the way to go, given that the built-in exp and natural log functions are only single-precision.

rem - return the nth root of real.double value x to stated precision

function nthroot(n, x, precision = real.double) = real.double

 

end

{{out}}

From the second version of the program.

=={{header|Scala}}==

Using tail recursion:

@tailrec

def rec(x0: Double) : Double = {

rec(a)

 

Alternatively, you can implement the iteration with an iterator like so:

 

=={{header|Scheme}}==

(define (good-enough? next guess)

(< (abs (- next guess)) tolerance))

(newline)

(display (root (expt 2 10) 10 0.001))

Output:

2.04732932236839

An alternate function which uses Newton's method is:

 

result

var float: x1 is 0.0;

x1 := (flt(pred(n)) * x0 + a / x0 ** pred(n)) / flt(n);

end while;

 

Original source: [http://seed7.sourceforge.net/algorith/math.htm#nthRoot]

=={{header|Sidef}}==

{{trans|Ruby}}

var x = 1.float

var prev = 0.float

}

 

 

A minor optimization would be to calculate the successive ''int(n-1)'' square roots of a number, then raise the result to the power of ''2**(int(n-1) / n)''.

 

{ a = nthroot(2, a, precision) } * int(n-1)

a ** (2**int(n-1) / n)

}

 

 

=={{header|Smalltalk}}==

 

{{trans|Tcl}}

nthRoot: n [

|x0 m x1|

]

]

 

((7131.5 raisedTo: 10) nthRoot: 10) displayNl.

 

=={{header|SPL}}==

 

nthroot(n,r)=

 

#.output(nthr(2,2))

{{out}}

<pre>

=={{header|Swift}}==

 

@inlinable

public func power(_ e: Int) -> Self {

 

print(81.root(n: 4))

 

{{out}}

=={{header|Tcl}}==

The easiest way is to just use the <code>pow</code> function (or exponentiation operator) like this:

expr {pow($A, 1.0/$n)}

However that's hardly tackling the problem itself. So here's how to do it using Newton-Raphson and a self-tuning termination test.<br>

{{works with|Tcl|8.5}}

set x0 [expr {$A / double($n)}]

set m [expr {$n - 1.0}]

set x0 $x1

}

Demo:

puts [nthroot 5 34]

puts [nthroot 5 [expr {34**5}]]

puts [nthroot 10 [expr 7131.5**10]]

Output:

<pre>1.414213562373095

 

=={{header|True BASIC}}==

LET precision = .00001

 

PRINT USING "####.########": (tmp ^ n)

NEXT n

 

=={{header|Ursala}}==

Error is on the order of machine precision because the stopping

criterion is either a fixed point or a repeating cycle.

#import flo

 

-+

("n","n-1"). "A". ("x". div\"n" plus/times("n-1","x") div("A",pow("x","n-1")))^== 1.,

This implementation is unnecessary in practice due to the availability of the library

function pow, which performs exponentiation and allows fractional exponents.

Here is a test program.

 

examples =

nthroot5 34.,

nthroot5 pow(34.,5.),

output:

<pre>

{{trans|Phix}}

The internal power operator "^" is used in stead of an auxiliary pow_ function and the accuracy has been reduced.

Dim eps As Double: eps = 0.00000000000001 '-- relative accuracy

Dim x As Variant: x = 1

nth_root 1000000000, 3

nth_root 1000000000, 9

<pre> 1024 10 2 2

27 3 3 3

=={{header|Wren}}==

{{trans|E}}

if (n < 2) Fiber.abort("n must be more than 1")

if (x <= 0) Fiber.abort("x must be positive")

for (trio in trios) {

System.print("%(trio[0]) ^ 1/%(trio[1])%(" "*trio[2]) = %(nthRoot.call(trio[0], trio[1]))")

 

{{out}}

 

=={{header|XBS}}==

send x^(1/a);

}{a=2};

{{out}}

<pre>

 

=={{header|XPL0}}==

 

func real NRoot(A, N); \Return the Nth root of A

RlOut(0, NRoot(27., 3.)); CrLf(0);

RlOut(0, NRoot(1024.,10.)); CrLf(0);

 

Output:

=={{header|Yabasic}}==

{{trans|AWK}}

 

do

return x

 

=={{header|zkl}}==

{{trans|Ruby}}

x:=prev:=a=a.toFloat(); n1:=nth-1;

do{

}