# Vector

**Vector** is a module designed to facilitate mathematical vector operations in the hermitian-style. For simplicity, I model only 3 dimensional vectors but allow the underlying fields to be arbitrary. **Complex** and **Double** serve as example fields throughout. The data type **ThreeVector** has a vector constructor: ** V3 x x x** and a scalar constructor:

**.**

`S x`

**ThreeVector**then extends the

**Functor**class with fmap mapping over the components in the obvious way.

```
import Data.Complex
data ThreeVector a = V3 a a a | S a deriving (Eq, Show)
instance Functor ThreeVector where
fmap f (V3 x y z) = V3 (f x) (f y) (f z)
fmap f (S x) = S $ f x
```

The **Comp** class introduces conjugation for **ThreeVectors**. **Complex** types are conjugated while **Double** types are left invariant.

```
class Comp c where
conj :: c -> c
instance Num a => Comp (Complex a) where
conj = conjugate
instance Comp Double where
conj = id
instance Comp a => Comp (ThreeVector a) where
conj = fmap conj
```

```
conj (2 :+ 3)
conj $ V3 (1 :+ 2) (3 :+ (-3)) (0 :+ 1)
conj $ V3 1 2 3
```

Now for the heart and soul of any module daring enough to call itself **Vector**.

The class **Vector** provides for the four base methods:

- innerproduct,
`()`

- norm, norm
- evaluation, eval
- projections, prs

Simultaneously, I extend **Num** to include **ThreeVector**. Extending provides meaning for summing, differencing, multiplying and taking the absolute value wrt **ThreeVector**. Notice that `abs`

relies on ` and `

`norm`

relies and `abs`

. This mutual dependency simplifies the code, but requires that both extensions are present at the time of compilation.

```
instance (Floating a, Num a, Comp a) => Num (ThreeVector a) where
(+) (V3 a b c) (V3 x y z) = V3 (a+x) (b+y) (c+z)
(-) (V3 a b c) (V3 x y z) = V3 (a-x) (b-y) (c-z)
(*) (V3 a b c) (S x) = V3 (a*x) (b*x) (x*x)
(*) (S x) (V3 a b c) = V3 (a*x) (b*x) (x*x)
abs vect = fmap sqrt (vect vect)
class Vector v where
(<|>) :: (Num a, Comp a) => v a -> v a -> v a
norm :: (Floating a, Comp a) => v a -> v a
eval :: Num a => v a -> v a
prs :: v a -> [a]
instance Vector ThreeVector where
(<|>) (V3 a b c) (V3 x y z) = V3 (conj a *x) (conj b *y) (conj c*z) -- Hermitian
eval (V3 a b c) = S $ a + b + c
prs (V3 a b c) = [a, b, c]
norm = eval.abs
```

Now we can take the Hermitian innerproduct of two complex vectors and return their evaluation.

```
x = V3 (1 :+ 2) (3 :+ (-3)) (0 :+ 1)
y = V3 (3 :+ 2) (1 :+ 2) (5 :+ (-2))
eval $ x <|> y
```