First, the new definitions:

```
data Region = UnitCircle
| Polygon [Coordinate]
| AffineTransform Matrix3x3 Region
| Empty
deriving Show
type Vector3 = (Float, Float, Float)
type Matrix3x3 = (Vector3, Vector3, Vector3)
type Matrix2x2 = ((Float, Float), (Float, Float))
```

And some old ones that will suffice unchanged:

```
type Coordinate = (Float, Float)
type Ray = (Coordinate, Coordinate)
isLeftOf :: Coordinate -> Ray -> Bool
(px,py) `isLeftOf` ((ax,ay), (bx,by))
= let (s,t) = (px-ax, py-ay)
(u,v) = (px-bx, py-by)
in s * v >= t * u
isRightOf :: Coordinate -> Ray -> Bool
(px,py) `isRightOf` ((ax,ay), (bx,by))
= let (s,t) = (px-ax, py-ay)
(u,v) = (px-bx, py-by)
in s * v <= t * u
containsR :: Region -> Coordinate -> Bool
(Polygon pts) `containsR` p
= let leftOfList = map isLeftOfp (zip pts (tail pts ++ [head pts]))
isLeftOfp p' = isLeftOf p p'
rightOfList = map isRightOfp (zip pts (tail pts ++ [head pts]))
isRightOfp p' = isRightOf p p'
in and leftOfList || and rightOfList
Empty `containsR` p = False
```

Now we have the new forms of `containsR` to write. The `UnitCircle` is easy:

`UnitCircle `containsR` (x,y) = x^2 + y^2 <= 1`

And in general, the transform of a region contains a point if the region contains the inverse transform of that point.

```
(AffineTransform m r) `containsR` (x,y)
= if determinant3 m == 0
then singularContains m (x,y)
else let m' = inverse m
(x', y', _) = matrixMul m' (x,y,1)
in r `containsR` (x', y')
```

Now some standard code for multiplying and inverting matrices:

```
matrixMul :: Matrix3x3 -> Vector3 -> Vector3
matrixMul (r1, r2, r3) v
= (dotProduct r1 v,
dotProduct r2 v,
dotProduct r3 v)
dotProduct :: Vector3 -> Vector3 -> Float
dotProduct (a,b,c) (x,y,z) = a*x + b*y + c*z
inverse :: Matrix3x3 -> Matrix3x3
inverse ((a,b,c), (d,e,f), (g,h,i))
= let det = determinant3 ((a,b,c), (d,e,f), (g,h,i))
a' = determinant2 ((e,f), (h,i)) / det
b' = determinant2 ((c,b), (i,h)) / det
c' = determinant2 ((b,c), (e,f)) / det
d' = determinant2 ((f,d), (i,g)) / det
e' = determinant2 ((a,c), (g,i)) / det
f' = determinant2 ((c,a), (f,d)) / det
g' = determinant2 ((d,e), (g,h)) / det
h' = determinant2 ((b,a), (h,g)) / det
i' = determinant2 ((a,b), (d,e)) / det
in ((a',b',c'), (d',e',f'), (g',h',i'))
determinant3 :: Matrix3x3 -> Float
determinant3 ((a,b,c), (d,e,f), (g,h,i))
= let aei = a * e * i
afh = a * f * h
bdi = b * d * i
cdh = c * d * h
bfg = b * f * g
ceg = c * e * g
in aei - afh - bdi + cdh + bfg - ceg
determinant2 :: Matrix2x2 -> Float
determinant2 ((a,b), (c,d))
= a * d - b * c
```

The only thing left is the question of how to deal with a singular (non-invertible) matrix. If an affine matrix is non-invertible, that means that AE - BD = 0. Either all four coefficients are 0, or AE = BD. If all 4 are 0, then every point in the region will be collapsed into the single point (C,F), and we need to check that this is the given point. If AE = BD otherwise, we have for any point `(x,y)` in the region:

x' = Ax + By + C y' = Dx + Ey + F Dx' = ADx + BDy + CD Ay' = ADx + AEy + AF = ADx + BDy + AF [AE = BD] âˆ´ Dx' - Ay' = CD - AF Dx' - Ay' + AF - CD = 0

so any point in the region will be collapsed into the line Dx' - Ay' + AF - CD = 0, and we need to check that the given point satisfies this equation.

```
singularContains :: Matrix3x3 -> Coordinate -> Bool
singularContains ((a,b,c), (d,e,f), _) (x,y)
= if (a == 0 && b == 0 && d == 0 && e == 0)
then (x == c && y == f)
else (d*x - a*y + a*f - c*d == 0)
```