Roots of unity: Difference between revisions

Given &nbsp; <big>'''n'''</big>, &nbsp; find the &nbsp; <big>'''n'''^th</big> &nbsp; [[wp:Roots of unity|roots of unity]].

<br><br>

 

=={{header|Ada}}==

with Ada.Float_Text_IO; use Ada.Float_Text_IO;

with Ada.Numerics.Complex_Types; use Ada.Numerics.Complex_Types;

end loop;

end loop;

[[Ada]] provides a direct implementation of polar composition of complex numbers ''x e''^{2&pi;''i y''}. The function Compose_From_Polar is used to compose roots. The third argument of the function is the cycle. Instead of the standard cycle 2&pi;, N is used. Sample output:

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

{{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) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

FOR root FROM 2 TO 10 DO

printf(($g(4)$,root));

OD;

printf($l$)

Output:

<pre>

+9 1.0000⊥0.0000 0.7660⊥0.6428 0.1736⊥0.9848 -.5000⊥0.8660 -.9397⊥0.3420 -.9397⊥-.3420 -.5000⊥-.8660 0.1736⊥-.9848 0.7660⊥-.6428

+10 1.0000⊥0.0000 0.8090⊥0.5878 0.3090⊥0.9511 -.3090⊥0.9511 -.8090⊥0.5878 -1.000⊥0.0000 -.8090⊥-.5878 -.3090⊥-.9511 0.3090⊥-.9511 0.8090⊥-.5878

</pre>

 

=={{header|AutoHotkey}}==

ahk forum: [http://www.autohotkey.com/forum/post-276712.html#276712 discussion]

Loop %n%

i := A_Index-1, t .= cos(a*i) ((s:=sin(a*i))<0 ? " - i*" . -s : " + i*" . s) "`n"

 

=={{header|AWK}}==

# syntax: GAWK -f ROOTS_OF_UNITY.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

{{trans|Java}}

For high n's, this may repeat the root of 1 + 0*i.

PI = 3.1415926#

n = 5 'this can be changed for any desired n

angle = angle + (2 * PI) / n

'all the way around the circle at even intervals

 

FOR n% = 2 TO 5

PRINT STR$(n%) ": " ;

NEXT

PRINT

'''Output:'''

<pre>

5: 1.0000 0.0000i, 0.3090 0.9511i, -0.8090 0.5878i, -0.8090 -0.5878i, 0.3090 -0.9511i

</pre>

 

=={{header|C}}==

#include <math.h>

 

 

return 0;

 

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

using System.Collections.Generic;

using System.Linq;

}

}

Output:

<pre>(1, 0)

 

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

#include <cmath>

#include <iostream>

std::cout << std::endl;

}

 

=={{header|CoffeeScript}}==

Most of the effort here is in formatting the results, and the output is still a bit clumsy.

nth_roots_of_unity = (n) ->

(complex_unit_vector(2*Math.PI*i/n) for i in [1..n])

console.log "---1 to the 1/#{n}"

for root in nth_roots_of_unity n

output

<pre>

 

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

(loop for i below n

The expression is slightly more complicated than necessary in order to preserve exact rational arithmetic until multiplying by pi. The author of this example is not a floating point expert and not sure whether this is actually useful; if not, the simpler expression is <tt>(cis (/ (* 2 pi i) n))</tt>.

 

=={{header|Crystal}}==

{{trans|Ruby}}

 

def roots_of_unity(n)

end

p roots_of_unity(3)

Or alternative

def roots_of_unity(n)

(0...n).map { |k| Complex.new(Math.cos(2 * Math::PI * k / n), Math.sin(2 * Math::PI * k / n)) }

end

{{out}}

<pre>

=={{header|D}}==

Using std.complex:

import std.math: PI;

 

foreach (immutable i; 1 .. 6)

writefln("#%d: [%(%5.2f, %)]", i, i.nthRoots);

{{out}}

<pre>#1: [ 1.00+ 0.00i]

{{libheader| System.VarCmplx}}

{{Trans|C#}}

program Roots_of_unity;

 

Writeln(num);

Readln;

{{out}}

<pre>

-0,5 - 0,866025403784439i

</pre>

=={{header|EchoLisp}}==

(define (roots-1 n)

(define theta (// (* 2 PI) n))

(roots-1 4)

→ (1+0i 0+i -1+0i 0-i)

 

=={{header|ERRE}}==

PROGRAM UNITY_ROOTS

 

UNTIL ANGLE>=2*π

END PROGRAM

Note: Adapted from Qbasic version. π is the predefined constant Greek Pi.

 

=={{header|Factor}}==

 

{{out}}

<pre>

=={{header|Forth}}==

Complex numbers are not a native type in Forth, so we calculate the roots by hand.

fdup 0e 0.001e f~ if fdrop 0e then f. ;

: .roots ( n -- )

 

3 set-precision

{{libheader|Forth Scientific Library}}

On the other hand, complex numbers are implemented by the FSL.

{{works with|gforth|0.7.9_20170308}}

{{trans|C++}}

require fsl/complex.fs

 

LOOP ;

3 SET-PRECISION

 

=={{header|Fortran}}==

===Sin/Cos + Scalar Loop===

{{works with|Fortran|ISO Fortran 90 and later}}

 

COMPLEX :: root

END DO

 

Output

2: +1.0000+0.0000j -1.0000+0.0000j

===Exp + Array-valued Statement===

{{works with|Fortran|ISO Fortran 90 and later}}

real, parameter :: pi = 3.141592653589793

complex, parameter :: i = (0, 1)

write(*,*)

end do

 

=={{header|Frink}}==

Calculates the angles in degrees, since Frink will use rational arithmetic (exact)

roots[n] :=

{

a

}

{{Out}}

<pre>

=={{header|FunL}}==

FunL has built-in support for complex numbers. <code>i</code> is predefined to represent the imaginary unit.

 

def rootsOfUnity( n ) = {exp( 2Pi i k/n ) | k <- 0:n}

 

 

{{out}}

<pre>

{1.0, -0.4999999999999998+0.8660254037844387i, -0.5000000000000004-0.8660254037844385i}

</pre>

 

=={{header|GAP}}==

 

r:=roots(7);

 

List(r, x -> x^7);

 

=={{header|Go}}==

 

import (

}

return r

Output:

<pre>2 roots of 1:

=={{header|Groovy}}==

Because the Groovy language does not provide a built-in facility for complex arithmetic, this example relies on the Complex class defined in the [[Complex_numbers#Groovy|Complex numbers]] example.

* useful in FFT calculations, among other things */

def rootsOfUnity = { n ->

Complex.fromPolar(1, 2 * Math.PI * it / n)

}

Test program:

 

((1..6) + [16]). each { n ->

assert rou.every { (it.rho - 1) < tol } : 'all roots should have magnitude 1'

println()

Output:

<pre style="height:25ex;overflow:scroll;">rootsOfUnity(1):

 

=={{header|Haskell}}==

 

rootsOfUnity :: (Enum a, Floating a) => a -> [Complex a]

 

main :: IO ()

{{Out}}

(-0.4999999999999998) :+ 0.8660254037844388

 

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

roots(10)

end

procedure str_rep(k)

return " " || cos(k) || "+" || sin(k) || "i"

Notes:

* The [[:Category:Icon_Programming_Library|The Icon Programming Library]] implements a complex type but not a polar type

=={{header|IDL}}==

For some example <tt>n</tt>:

Outputs:

 

=={{header|J}}==

 

rou 4

 

rou 5

The computation can also be written as a loop, shown here for comparison only.

z=. 0 $ r=. ^ o. 0j2 % y [ e=. 1

for. i.y do.

end.

z

 

=={{header|Java}}==

Java doesn't have a nice way of dealing with complex numbers, so the real and imaginary parts are calculated separately based on the angle and printed together. There are also checks in this implementation to get rid of extremely small values (< 1.0E-3 where scientific notation sets in for <tt>Double</tt>s). Instead, they are simply represented as 0. To remove those checks (for very high <tt>n</tt>'s), remove both if statements.

 

public class Test {

}

}

 

<pre>2: ( 1.000000, 0.000000) (-1.000000, 0.000000)

 

=={{header|JavaScript}}==

with (Math) { this.r = cos(angle); this.i = sin(angle) }

}

document.write('<br>')

}

{{Output}}

<pre>2: 1.00000+0.00000i, -1.00000+0.00000i

=={{header|jq}}==

Using the same example as in the Julia section, and representing x + i*y as [x,y]:

(8 * (1|atan)) as $twopi

| range(0;n) | (($twopi * .) / n) as $angle | [ ($angle | cos), ($angle | sin) ];

 

Darwin Mac-mini 13.3.0 Darwin Kernel Version 13.3.0: Tue Jun 3 21:27:35 PDT 2014; root:xnu-2422.110.17~1/RELEASE_X86_64 x86_64

 

user 0m0.004s

sys 0m0.004s

 

=={{header|Julia}}==

(One could also use complex exponentials or other formulations.) For example, `nthroots(10)` gives:

<pre>

 

=={{header|Kotlin}}==

 

data class Complex(val r: Double, val i: Double) {

(1..4).forEach { println(listOf(1) + unity_roots(it)) }

println(listOf(1) + unity_roots(5.0))

{{out}}

<pre>[1]

 

=={{header|Lambdatalk}}==

// cleandisp just to display 0 when n < 10^-10

{def cleandisp

i = 10 -> (1 0) (0.8090169943749475 0.5877852522924731) (0.30901699437494745 0.9510565162951535) (-0.30901699437494734 0.9510565162951536) (-0.8090169943749473 0.5877852522924732) (-1 0) (-0.8090169943749475 -0.587785252292473) (-0.30901699437494756 -0.9510565162951535) (0.30901699437494723 -0.9510565162951536) (0.8090169943749473 -0.5877852522924732)

 

 

=={{header|Lua}}==

Complex numbers from the Lua implementation on the complex numbers page.

complex = setmetatable({

__add = function(u, v) return complex(u.real + v.real, u.imag + v.imag) end,

root = root * val

print(root .. "")

 

=={{header|Maple}}==

solve(z^n = 1, z);

printf( "%d: %a\n", i, [ RootsOfUnity(i) ] );

Output:

3: [1, -1/2-1/2*I*3^(1/2), -1/2+1/2*I*3^(1/2)]

4: [1, -1, I, -I]

5: [1, 1/4*5^(1/2)-1/4+1/4*I*2^(1/2)*(5+5^(1/2))^(1/2), -1/4*5^(1/2)-1/4+1/4*I*2^(1/2)*(5-5^(1/2))^(1/2), -1/4*5^(1/2)-1/4-1/4*I*2^(1/2)*(5-5^(1/2))^(1/2), 1/4*5^(1/2)-1/4-1/4*I*2^(1/2)*(5+5^(1/2))^(1/2)]

 

Setting this up in Mathematica is easy, because it already handles complex numbers:

Note that Mathematica will keep the expression as exact as possible. Simplifications can be made to more known (trigonometric) functions by using the function ExpToTrig. If only a numerical approximation is necessary the function N will transform the exact result to a numerical approximation. Examples (exact not simplified, exact simplified, approximated):

<pre>RootsUnity[2]

 

=={{header|MATLAB}}==

 

assert(n >= 1,'n >= 1');

z = roots([1 zeros(1,n-1) -1]);

Sample Output:

 

ans =

-0.500000000000000 + 0.866025403784439i

-0.500000000000000 - 0.866025403784439i

 

=={{header|Maxima}}==

Demonstration:

Output:

solve(1 = x^2, x) = [x = -1, x = 1]

solve(1 = x^3, x) = [x = (sqrt(3)*%i-1)/2, x = -(sqrt(3)*%i+1)/2, x = 1]

solve(1 = x^4, x) = [x = %i, x = -1, x = -%i, x = 1]

 

=={{header|MiniScript}}==

complexRoots = function(n)

result = []

for i in range(2,5)

print i + ": " + complexRoots(i).join(", ")

 

{{out}}

 

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

 

=={{header|Nim}}==

 

 

 

for nr in 2..10:

 

=={{header|OCaml}}==

 

let pi = 4. *. atan 1.

done;

print_newline ()

 

=={{header|Octave}}==

printf("*** %d\n", j);

for n = 1 : j

endfor

disp("");

 

=={{header|OoRexx}}==

{{trans|REXX}}

parse Version v

Say v

if abs(x)<near0 then x=0 /*if near zero, then assume zero.*/

return format(x,,frac)/1 /*fraction digits past dec point.*/

{{out}}

<pre>D:\>rexx nrootoo 5

 

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

 

<code>sqrtn()</code> can give the first n'th root, from which the others by multiplying or powering.

 

 

Both the above give floating point complex numbers even when a root could be exact, like <code>-1</code> or fourth root <code>I</code>.

<code>quadgen()</code> can be used for an exact 6th root. (Quads cannot be mixed with ordinary complex numbers, and they always print as <code>w</code>.)

 

 

=={{header|Pascal}}==

{{trans|Fortran}}

 

var

writeln;

end;

Output:

<pre>

The <code>root()</code> function returns a list of the N many N'th roots of any complex Z, in this case 1.

 

foreach my $n (2 .. 10) {

}

print "\n";

Output:

<pre>

=={{header|Phix}}==

{{trans|AWK}}

<pre style="font-size: 10px">

2: 1.000 0.000i, -1.000 0.000i

=={{header|PicoLisp}}==

{{trans|C}}

 

(for N (range 2 10)

" " ) )

(inc 'Angle (*/ 2 pi N)) )

 

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

procedure (N);

declare N fixed binary nonassignable;

-0.30901709-0.95105648I

0.30901712-0.95105648I

 

=={{header|Prolog}}==

Solves the roots of unity symbolically, as complex powers of e.

roots(N, Rs) :-

succ(Pn, N), numlist(0, Pn, Ks),

cis(1 rdiv Q, exp(i*pi/Q)) :- !.

cis(P rdiv Q, exp(P*i*pi/Q)).

{{Out}}

<pre>

X = [1, exp(i*pi/4), i, exp(3*i*pi/4), -1, exp(... * ... * pi/4), -i, exp(... / ...)].

</pre>

 

=={{header|Python}}==

{{works with|Python|3.7}}

 

 

 

for nr in range(2, 11):

{{Out}}

<pre>2 [1.00000, -1.00000]

 

=={{header|R}}==

r <- sprintf("%d: ", j)

for(n in 1:j) {

}

print(r)

Output:

<pre>

 

=={{header|Racket}}==

 

(define (roots-of-unity n)

(for/list ([k n])

Will produce a list of roots, for example:

<pre>

Raku has a built-in function <tt>cis</tt> which returns a unitary complex number given its phase. Raku also defines the <tt>tau = 2*pi</tt> constant. Thus the k-th n-root of unity can simply be written <tt>cis(k*τ/n)</tt>.

 

for ^n -> \k {

say cis(k*τ/n);

 

{{out}}

0.309016994374947-0.951056516295154i

0.809016994374947-0.587785252292473i</pre>

 

=={{header|REXX}}==

 

Note: &nbsp; this REXX version only &nbsp; ''displays'' &nbsp; '''5''' &nbsp; significant digits past the decimal point, &nbsp; but this can be overridden by specifying the 2^nd argument when invoking the REXX program. &nbsp;

numeric digits length( pi() ) - length(.) /*use number of decimal digits in pi. */

parse arg n frac . /*get optional arguments from the C.L. */

if Ip>=0 then Ip= '+'Ip /* " " " " " " plus " */

if Ip =0 then say Rp /*Only real part? Ignore imaginary part*/

end /*angle*/

end /*#*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

sin: procedure; parse arg x; x= r2r(x); numeric fuzz min(5, digits() - 3)

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 5 </tt>}}

<pre>

 

=={{header|Ring}}==

decimals(4)

for n = 2 to 5

see nl

next

 

=={{header|RLaB}}==

:<math>x^n - 1 = 0.</math>

It uses the solver ''polyroots''. Interested user is recommended to check the rlabplus manual for details on the solver and the parameters that tune the solver performance.

>> n = 10;

>> a = zeros(1,n+1); a[1] = 1; a[n+1] = -1;

1 + 0i

0.809016994 + 0.587785252i

 

=={{header|Ruby}}==

(0...n).map {|k| Complex.polar(1, 2 * Math::PI * k / n)}

end

 

 

{{out}}

[(1+0.0i), (-0.4999999999999998+0.8660254037844387i), (-0.5000000000000004-0.8660254037844384i)]

</pre>

 

=={{header|Rust}}==

Here we demonstrate initialization from polar complex coordinate, radius 1, e^πi/n, and raising the resulting complex number to the power 2k for k in 0..n-1, which generates approximate roots (see the Mathematica answer for a nice display of exact vs approximate). This code will require adding the num crate to one's rust project, typically in Cargo.toml <i>[dependencies] \n num="0.2.0";</i>

fn main() {

let n = 8;

println!("e^{:2}πi/{} ≈ {:>14.3}",2*k,n,z.powf(2.0*k as f64));

}

<pre>

e^ 0πi/8 ≈ 1.000+0.000i

=={{header|Scala}}==

Using [[Arithmetic/Complex#Scala|Complex]] class from task Arithmetic/Complex.

Usage:

<pre>rootsOfUnity(3) foreach println

 

=={{header|Scheme}}==

 

(do ((n 2 (+ n 1)))

(display " ")

(display (make-polar 1 (* 2 pi (/ k n)))))

 

=={{header|Seed7}}==

include "float.s7i";

include "complex.s7i";

writeln;

end for;

Output:

3: 1.0000+0.0000i -0.5000+0.8660i -0.5000-0.8660i

4: 1.0000+0.0000i 0.0000+1.0000i -1.0000+0.0000i 0.0000-1.0000i

8: 1.0000+0.0000i 0.7071+0.7071i 0.0000+1.0000i -0.7071+0.7071i -1.0000+0.0000i -0.7071-0.7071i 0.0000-1.0000i 0.7071-0.7071i

9: 1.0000+0.0000i 0.7660+0.6428i 0.1736+0.9848i -0.5000+0.8660i -0.9397+0.3420i -0.9397-0.3420i -0.5000-0.8660i 0.1736-0.9848i 0.7660-0.6428i

 

=={{header|Sidef}}==

{{trans|Raku}}

n.of { |j|

exp(2i * Num.pi / n * j)

roots_of_unity(5).each { |c|

printf("%+.5f%+.5fi\n", c.reals)

{{out}}

<pre>

 

=={{header|Sparkling}}==

// nth-root(1) = cos(2 * k * pi / n) + i * sin(2 * k * pi / n)

return map(range(n), function(idx, k) {

foreach(unity_roots(6), function(k, v) {

printf("%.3f%+.3fi\n", v.re, v.im);

 

=={{header|Stata}}==

 

exp(2i*pi()/n*(0::n-1))

1

6 | -.222520934 - .974927912i |

7 | .623489802 - .781831482i |

 

=={{header|Tcl}}==

namespace import tcl::mathfunc::*

 

}

puts $row

 

=={{header|VBA}}==

For n = 2 To 9

Debug.Print n; "th roots of 1:"

Debug.Print

Next n

<pre> 2 th roots of 1:

Root 0: 1

Root 7: 0.17364817766693-0.984807753012208i

Root 8: 0.766044443118978-0.64278760968654i</pre>

 

=={{header|Wren}}==

{{libheader|Wren-complex}}

{{libheader|Wren-fmt}}

 

var roots = Fn.new { |n|

for (n in 2..5) {

Fmt.print("$d roots of 1:", n)

 

{{out}}

<pre>

2 roots of 1:

3 roots of 1:

4 roots of 1:

5 roots of 1:

</pre>

 

=={{header|zkl}}==

{{trans|C}}

foreach n,i in ([1..9],n){

c:=s:=0;

print( (s==1 and "i") or (s==-1 and "-i" or (s and "%+.2gi" or"")).fmt(s));

print( (i==n-1) and "\n" or ", ");

{{out}}

<pre>