Nth root: Difference between revisions

 

<br><br>

 

=={{header|360 Assembly}}==

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>

Root= +2.000000000000000

Root= +1.414213562373095

</pre>

 

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

See also the [[#Liberty BASIC|Liberty BASIC]] and [[#PureBasic|PureBasic]] solutions.

 

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

PROCEDURE nth

PARAM N : INTEGER; A, P : REAL

PRINT "The Root is: ";TEMP1

END

 

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

Cube root of 5 is 1.709975946677

125th root of 5643 is 1.071549111198

</pre>

 

=={{header|bc}}==

* 'n' must be an integer.

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

scale = o

return(y)

 

=={{header|Bracmat}}==

= 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

2^(1/2)=1,4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727*10E0

5642^(1/125)=1,07154759194476751170*10E0</pre>

 

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

2</pre>

 

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

 

.

.

 

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

until

(uncurry (==))

(x, x / n)

 

-------------------------- TESTS --------------------------

(uncurry nthRoot)

[(2, 2), (5, 34), (10, 734 ^ 10), (0.5, 7)]

 

-------------------- FORMAT OF RESULTS --------------------

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

2.0 ^ 1/2 = 1.414213562373095

</pre>

 

=={{header|langur}}==

Langur has a root operator. Here, we show use of both the root operator and an nth root function.

 

{{trans|D}}

writeln 64 ^/ 6

writeln()

 

# To make the example from the D language work, we set a low maximum for the number of digits after a decimal point in division.

mode divMaxScale = 7

 

 

{{out}}

2

 

7131.5

2

</pre>

 

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

</pre>

 

 

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

 

var n = float(n)

result = a

var x = a / n

x = result

 

Output:

 

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

{{out}}

<pre>

</pre>

 

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

X = -3.

</pre>

 

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

 

}

 

 

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

cube root of 5 is : 1.709975946677

</pre>

 

=={{header|Ruby}}==

x = Float(a)

begin

end

 

 

 

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

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>

</pre>

 

</pre>

 

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

1024 ^ 1/10 = 2

2 ^ 1/2 = 1.4142135623731

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

2.000000000000000

</pre>

 

=={{header|zkl}}==

{{trans|Ruby}}

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

do{

}