# Scientific Programming in Haskell with hmatrix

I’ve been puttering around with some ideas about how linear algebra could work in Haskell.

So I decided to check out what has been done. hmatrix binds to the gnu scientific libraries and lapack.

There is also htensor and repa which I need to check out.

This is the hello word of scientific programs. I could write this is numpy, scipy, matplotlib FAST. But I’m super used to those. Maybe not a fair comparison.

I build a circulant function for the 1d periodic Laplace equation matrix. I did not find good constructors that would elegantly construct the thing so I make a circulant routine using the fft. That’s ok I guess.

I got the eigenvalues and eigenvectors with eigSH.

Then I plot it out to an external svg file using Cairo. I do not like the mental overhead of a monad.But I guess you can just copy and paste and ignore all that.

The Plt.line function takes a label and a list of (x,y) tuples

```
runghc hello_laplace.hs
-- runghc Laplace.hs
import Numeric.GSL.Fourier
import Numeric.LinearAlgebra
import Data.Complex
-- Some of the namespace crashes with the algebra stuff.
import qualified Graphics.Rendering.Chart.Easy as Plt
import Graphics.Rendering.Chart.Backend.Diagrams(toFile)
fftRow m = fromRows $ (map fft) $ toRows m
fftCol m = fromColumns $ (map fft) $ toColumns m
ifftRow :: Matrix (Complex Double) -> Matrix (Complex Double)
ifftRow m = fromRows $ (map ifft) $ toRows m
ifftCol m = fromColumns $ (map ifft) $ toColumns m
circulant :: Vector (Complex Double) -> Matrix (Complex Double)
circulant v = ifftCol $ fftRow $ diag $ fft v
{-
-- nevermind
rotate :: Int -> [a] -> [a]
rotate _ [] = []
rotate n xs = zipWith const (drop n (cycle xs)) xs
-}
num = 20
c = assoc num 0 [(0,-2),(1,1),(num-1,1)] :: Vector C
kmat = circulant c
sol = eigSH (trustSym kmat)
-- doesn't check hermiticty
--sol = eigSH' kmat
eigvals = fst sol
-- a plotting function
signal :: [Int] -> [(Double,Double)]
signal xs = [ (fromIntegral x, realPart $ (c ! x) )| x <- xs ]
pltVec label v = (Plt.line label [zip [0..] (toList v)])
main = toFile Plt.def "example1_big.svg" $ do
Plt.plot (Plt.line "Matrix Row" [signal [0..(num-1)]])
Plt.plot (pltVec "eigenvalues" eigvals)
```

Ok. Actually on reflection it’s not bad. Scratching my head around the circulant matrix constructor took some time. And so did installing stuff. I did also keep slamming into type mismatches. and it didn’t like eigSH’ which I don’t get.

Maybe Haskell for Mac would work well here? I did buy a copy.

Maybe Julia would be better? I think Julia has lots of functional and pythony things.

I should refactor the fftRow stuff into a higher order combinator that maps into rows and columns

```
mapRow f m = fromRows $ (map f) $ toRows m
```