Eigenvalues of a Matrix
Haskell, 576 554 532 507 bytes



No built-ins!

import Data.Complex
s=sum
l=length
m=magnitude
i=fromIntegral
(&amp;)=zip
t=zipWith
(x!a)b=x*a+b
a#b=[[s$t(*)x y|y&lt;-foldr(t(:))([]&lt;$b)b]|x&lt;-a]
f a|let c=[1..l a];g(u,d)k|m&lt;-[t(+)a b|(a,b)&lt;-a#u&amp;[[s[d|x==y]|y&lt;-c]|x&lt;-c]]=(m,-s[s[b|(n,b)&lt;-c&amp;a,n==m]|(a,m)&lt;-a#m&amp;c]/i k)=snd&lt;$&gt;scanl g(0&lt;$c&lt;$c,1)c
p?x|let f=foldl1(x!);c=l p-1;n=i c;q p=init$t(*)p$i&lt;$&gt;[c,c-1..];o=f(q p)/f p;a|d&lt;-sqrt$(n-1)*(n*(o^2-f(q$q p)/f p)-o^2)=n/last(o-d:[o+d|m(o-d)&lt;m(o+d)])=last$p?(x-a):[x|m a&lt;1e-9]
z[a,b]=[-b/a]
z p=p?0:z(init$scanl1(p?0!)p)


Try it online!

Many thanks @ØrjanJohansen for a total of -47 bytes!

Explanation

First this computes the characteristic polynomial with the Faddeev–LeVerrier algorithm which is the function f. Then the function z computes all roots of that polynomial by iterating g which implements Laguerre's Method for finding a root, once a root is found it is removed and g gets called again until the polynomial has degree 1 which is trivially solved by z[a,b]=[-b/a].

Ungolfed

I re-inlined the functions sum,length,magnitude, fromIntegral, zipWith and (&amp;) as well as the little helper (!). The function faddeevLeVerrier corresponds to f, roots to z and g to laguerre respectively.

-- Transpose a matrix/list
transpose a = foldr (zipWith(:)) (replicate (length a) []) a

-- Straight forward implementation for matrix-matrix multiplication
(#) :: [[Complex Double]] -&gt; [[Complex Double]] -&gt; [[Complex Double]]
a # b = [[sum $ zipWith (*) x y | y &lt;- transpose b]|x&lt;-a]


-- Faddeev-LeVerrier algorithm
faddeevLeVerrier :: [[Complex Double]] -&gt; [Complex Double]
faddeevLeVerrier a = snd &lt;$&gt; scanl go (zero,1) [1..n]
  where n = length a
        zero = replicate n (replicate n 0)
        trace m = sum [sum [b|(n,b)&lt;-zip [1..n] a,n==m]|(m,a)&lt;-zip [1..n] m]
        diag d = [[sum[d|x==y]|y&lt;-[1..n]]|x&lt;-[1..n]]
        add as bs = [[x+y | (x,y) &lt;- zip a b] | (b,a) &lt;- zip as bs]
        go (u,d) k = (m, -trace (a#m) / fromIntegral k)
          where m = add (diag d) (a#u)


-- Compute roots by succesively removing newly computed roots
roots :: [Complex Double] -&gt; [Complex Double]
roots [a,b] = [-b/a]
roots   p   = root : roots (removeRoot p)
  where root = laguerre p 0
        removeRoot = init . scanl1 (\a b -&gt; root*a + b)

-- Compute a root of a polynomial p with an initial guess x
laguerre :: [Complex Double] -&gt; Complex Double -&gt; Complex Double
laguerre p x = if magnitude a &lt; 1e-9 then x else laguerre p new_x
  where evaluate = foldl1 (\a b -&gt; x*a+b)
        order' = length p - 1
        order  = fromIntegral $ length p - 1
        derivative p = init $ zipWith (*) p $ map fromIntegral [order',order'-1..]
        g  = evaluate (derivative p) / evaluate p
        h  = (g ** 2 - evaluate (derivative (derivative p)) / evaluate p)
        d  = sqrt $ (order-1) * (order*h - g**2)
        ga = g - d
        gb = g + d
        s = if magnitude ga &lt; magnitude gb then gb else ga
        a = order /s
        new_x = x - a