final cog

-- 10
data Direction = LeftTurn
               | RightTurn
               | StraightOn
                 deriving (Show, Eq)
 
-- 11
data Point = Point {
      pointX :: Double,
      pointY :: Double
} deriving (Show, Eq)
 
data Vector = Vector {
      startP :: Point,
      endP   :: Point
} deriving (Show, Eq)
 
getAngle :: Vector -> Double
getAngle v = atan2 y x
           where x = pointX (endP v) - pointX (startP v)
                 y = pointY (endP v) - pointY (startP v)
 
 
getDirection:: Point -> Point -> Point -> Direction
getDirection x y z | getAngle (Vector x y) < getAngle (Vector y z) = LeftTurn
                   | getAngle (Vector x y) > getAngle (Vector y z) = RightTurn
                   | otherwise = StraightOn
 
-- 12
getDirectionList :: [Point] -> [Direction]
getDirectionList xs | length xs < 3 = []
                    | otherwise = [getDirection a b c] ++ getDirectionList (tail xs)
                    where a = head xs
                          b = head (tail xs)
                          c = head (tail (tail xs))

numItems [] = 0
numItems (x:xs) = 1 + numItems xs

numItems :: [a] -> Int 

myMean [] = error "list must have some elements"
myMean (x:[]) = x
myMean xs = (sum xs) / fromIntegral(length xs)

--improved error handling p.61
 
myMean2 [] = Nothing   
myMean2 (x:[]) =  Just x
 -- All the equations for a function must return 
 -- the same type! No, it was never explicitly 
 -- stated in the book.  The first equation 
 -- returns a Maybe type, so they all must. As far 
 -- as I can tell, when a function is defined as a 
 -- series of equations, each equation must have
 -- the same type of parameters, and each result
 -- must be the same type.
myMean2 xs =
    let len = fromIntegral(length xs)
    in let result = (sum xs)/len
        in Just result

--list to palindrome 
 
l2p [] = []
l2p [x] = [x, x]
l2p xs =  xs ++ reverseIt xs
    where reverseIt [] = []
          reverseIt [x] = [x]   
          reverseIt xs = last xs : reverseIt(take (length xs - 1) xs)

isPali xs
    |xs == reverseIt xs     = True
    |otherwise              = False
   where reverseIt [] = []
         reverseIt [x] = [x]
         reverseIt xs = last xs : reverseIt(take (length xs - 1) xs)

import Data.List (sortBy)
 
mySort xs = sortBy myCompare xs
    where myCompare x y 
              | lx < ly    = LT
              | lx == ly   = EQ
              | lx > ly    = GT        
             where lx = length x
                   ly = length y

intersperse sep xs
    | null xs            = ""
    | length xs == 1     = head xs
    | length xs > 1      = head xs ++ sep ++ intersperse sep (tail xs)

data Tree a = Node a (Tree a) (Tree a)
            | Empty
              deriving (Show)
 
height Empty = 0
height (Node _ Empty Empty)  = 1
height (Node _ node Empty) = 1 + height node  --go up left branch 
height (Node _ Empty node) = 1 + height node  --go up right branch
height (Node _ node1 node2)  --when first Node is connected to two Nodes
    | height node1 == height node2    = 1 + height node1
    | height node1 > height node2     = 1 + height node1
    | height node1 < height node2     = 1 + height node2

                                          Empty   Empty
                                             \    /
                                              \  /
                                     Empty   Node 14
                                         \    /
                                          \  /
                                         Node 12  Empty
                                             \    /
                                              \  /
                                      Empty  Node 10
                                         \     /
                                          \   /
                  Empty   Empty   Node 7  Node 8
                      \    /          \     /
                       \  /            \   /
              Empty  Node 120   Empty  Node 6
                  \    /          \     /
                   \  /            \   /  
                 Node 100         Node 4
                      \             /
                       \           /
                        \         /
                         \       /
                          Node 2

*Main> let n120 = Node 120 Empty Empty
*Main> let n100 = Node 100 Empty n120
 
*Main> let n14 = Node 14 Empty Empty
*Main> let n12 = Node 12 Empty n14
*Main> let n10 = Node 10 n12 Empty
*Main> let n8 = Node 8 Empty n10
 
*Main> let n7 = Node 7 Empty Empty
*Main> let n5 = Node 5 Empty n7
 
*Main> let n6 = Node 6 n5 n8
*Main> let n4 = Node 4 Empty n6
*Main> let n2 = Node 2 n100 n4
*Main> n2
Node 2 (Node 100 Empty (Node 120 Empty Empty)) (Node 4 Empty (Node 6 (Node 5 Empty (Node 7 Empty Empty)) 
(Node 8 Empty (Node 10 (Node 12 Empty (Node 14 Empty Empty)) Empty))))
 
*Main> height n2
7

data Direction = LeftTurn
               | RightTurn
               | Straight
                 deriving (Show)

*Main> whichWay (-2, 5) (4, 4) (5, -2)
RightTurn  --ok
*Main> whichWay (4,4) (-2, 5) (5, -2)
RightTurn  --wrong

whichWay (x1, y1) (x2, y2) (x3, y3)
 
{-In the formula for the slope of a line:
 
m = (y2 - y1)/(x2 - x1)
 
when the term (x2 - x1) is zero, you cannot use the slope intercept
equation for a line. When (x2 - x1) is equal to 0, the line drawn
from the 1st point to the 2nd point is a vertical line.
-}
 
--Cases where the line between the first two points is vertical:
    | x2 == x1 {-vertical line-} 
      && x3 == x2 {-3rd point is on line-}                  = Straight
 
      ---------------------
 
    | x2 == x1 {-vertical line-}
      && y2 < y1 {-2nd point is lower than 1st point-}
      && x3 < x2 {-3rd point is to left of line-}           = RightTurn
 
    | x2 == x1 {-vertical line-}
      && y2 < y1 {-2nd point is lower than 1st point-}
      && x3 > x2 {-3rd point is to right of line-}          = LeftTurn
 
     -----------------------
 
    | x2 == x1 {-vertical line-}
      && y2 > y1 {-2nd point is higher than 1st point-}
      && x3 < x2 {-3rd point is to left of line-}           = LeftTurn
 
    | x2 == x1 {-vertical line-}
      && y2 > y1 {-2nd point is higher than 1st point-}
      && x3 > x2 {-3rd points is to right of line-}         = RightTurn
 
--Cases where the slope intercept equation for a line can be used:
    | y3 == m*x3 + b {-3rd point is on line-}               = Straight
 
     ------------------------
 
    | y3 > m*x3 + b {-3rd point is above line-}
      && x2 < x1 {-2nd point is to left of 1st point-}      = RightTurn
 
    | y3 > m*x3 + b {-3rd point is above line-}
      && x2 > x1 {-2nd point is to right of 1st point-}     = LeftTurn
 
    | y3 < m*x3 + b {-3rd point is below line-}
      && x2 < x1 {-2nd point is to left of 1st point-}      = LeftTurn
 
    | y3 < m*x3 + b {-3rd point is above line-}
      && x2 > x1 {-2nd point is to right of 1st point-}     = RightTurn
 
   where m = (y2 - y1)/(x2 - x1)
         b = y - m*x
            where y = y2
                  x = x2

getDirections [] = error "list should contain at least 3 points"
getDirections (_:[]) = error "list should contain at least 3 points"
getDirections (_:_:[]) = error "list should contain at least 3 points"
getDirections (p1:p2:p3:[]) = [whichWay p1 p2 p3]
getDirections ps = let p1 = head ps
                       p2 = head (tail ps)
                       p3 = head (drop 2 ps)
                   in (whichWay p1 p2 p3) : getDirections (tail ps)

cotangent =  (adjacent side)/(opposite side)

                       . S (4, 5)
                      /|
                    /  |
                  /    | opp
                /      |
              .________|              
      (0, 0) P   adj

(4-0)/(5-0) = 4/5 

                      B
                      . (0, 3)
                      |             
            C         |         A  
   (-3, 2)  .         |         . (3, 2)
                      |      
----------------------.--------------
                      | P
   (-3, -2) .         |         . (3, -2)
            D         |         E
                      |

A : (3-0) / (2-0) = 3/2
 
B: As you move point A closer and closer to point B, the adjacent side gets smaller and smaller until 
it goes to zero.  So point B's adjacent side is 0, which makes the cotangent = 0/something, which is 0.
 
C: (-3-0) / (2-0) = -3/2      Ah hah!  The sign changes. :)
 
 
D: (-3-0) / (-2-0) = 3/2     Hmmm...That is the same answer as for A.  :(
 
E: (3-0) / (-2-0) = -3/2     Uggh.  Same answer as for C.

{-
The following is a function that when given a list of pairs representing 
points finds the lowest point, i.e. the point with the smallest y coordinate.
In the case of ties, the point that lies furthest to the left, i.e. the one
with the smallest x coordinate is returned.
 
My strategy was to remove the first point in the list and compare it to
the last point in the list.  If the first point is a better P than
the last point, then the first point is appended to the end of the list.
Otherwise, the first point is discarded. Eventually, the list gets whittled 
down to one element, and that element is P.  
 
The efficiency will be O(2n) when every succeeding point in the list is a 
better candidate for P than the previous point because no points will be 
eliminated from the list until the list is 2*n long. But O(2n) is considered
to be O(n).  A for loop would be more efficient because it is always O(n).
-}
 
getP [] = error "empty list"
getP (p:[]) = p
getP (p:ps)
    | snd p < snd (last ps)         = getP (ps ++ [p])
      -- If y of first point in list is lower than y of last point in list,
      -- add the first point to end of list because it is a better P candidate.
 
    | snd p == snd (last ps)
      && fst p < fst (last ps)      = getP (ps ++ [p])
      -- If y of first point in list is the same height as y of last point in list,
      -- then check x coords.  If x of first point in list is further left than x of
      -- last point in list then add the first point to end of list because it is
      -- a better P candidate.
 
    | snd p == snd (last ps)
      && fst p > fst (last ps)      = getP ps
      -- If y of first point in list is the same height as y of last point in list,
      -- then check x coords.  If x of first point in list is to the right of the x of
      -- last point in list, then discard first point since it is not a better
      -- candidate for P than the last point in the list.
 
    | snd p > snd (last ps)         = getP ps
      --If y of first point in list is higher than y of last point in list, then
      --discard first point since it is cannot be P.

cotanSort p ps = sortBy myCompare ps
            where myCompare p1 p2
 
                --cotangent p->p1 = (p1x - px)/(p1y - py)
                --Calculating the cotangent for a few random points shows that the
                --bigger the cotangent, the smaller the angle that the line segment
                --forms with the x axis.  The sort should be from smallest angle 
                --to the biggest angle, which is the same as largest cotangent to
                --smallest cotangent.  Also, if the line segments p->p1 and p->p2 form the  
                --same angle with the x axis, i.e. their cotangents are the same, then the 
                --point closer to p should come earlier in the sorted list.
 
                    --Cases where p1 and p2 have the same cotangents:
                    | p1 == p2              = EQ
 
                    | p1y - py == 0  {-then cotangent of p->p1 is infinite-}
                      && p2y - py == 0 {-then cotangent of p->p2 is infinite-}
                      && p1x < p2x          = LT  {-p1 is closer to p-}
                    | p1y - py == 0  {-then cotangent of p->p1 is infinite-}
                      && p2y - py == 0 {-then cotangent of p->p2 is infinite-}
                      && p1x > p2x          = GT  {-p2 is closer to p-}
 
                    | cotanp1 == cotanp2
                      && cotanp1 > 0 {-then p1 and p2 are in 1st quadrant relative to p-}
                      && p1x < p2x          = LT {-then p1 is closer to p-}
                    | cotanp1 == cotanp2
                      && cotanp1 > 0 {-then p1 and p2 are in 1st quadrant relative to p-}
                      && p1x > p2x          = GT {-then p2 is closer to p-}
 
                    | cotanp1 == cotanp2
                      && cotanp1 == 0 {-then p1 and p2 are directly above p-}
                      && p1y < p2y          = LT {-then p1 is closer to p-}
                    | cotanp1 == cotanp2
                      && cotanp1 == 0 {-then p1 and p2 are directly above p-}
                      && p1y > p2y          = GT {-then p2 is closer to p-}
 
                    | cotanp1 == cotanp2
                      && cotanp1 < 0 {-then p1 and p2 are in 2nd quadrant relative to p-}
                      && p1x > p2x          = LT {-then p1 is closer to p-}
                    | cotanp1 == cotanp2
                      && cotanp1 < 0 {-then p1 and p2 are in 2nd quadrant relative to p-}
                      && p1x < p2x          = GT {-then p2 is closer to p-}
 
 
                    --Cases where p1 and p2 have different cotagents: 
                    | p1y - py == 0         = LT  --If gets here then p1 and p2 can't both
                                                  --have infinite cotangents.
                    | p2y - py == 0         = GT  --If gets here then only p2 can have an
                                                  --infinite cotangent.
                    | cotanp1 < cotanp2     = GT
                    | cotanp1 > cotanp2     = LT
 
                    where p1x = fst p1
                          p1y = snd p1
                          p2x = fst p2
                          p2y = snd p2
                          px = fst p
                          py = snd p
                          cotanp1 = (p1x - px)/(p1y - py)
                          cotanp2 = (p2x - px)/(p2y - py)

if whichWay p1 p2 p3 == RightTurn
then 1
else 2

   No instance for (Eq Direction)
      arising from a use of `==' at <interactive>:1:3-14
    Possible fix: add an instance declaration for (Eq Direction)
    In the predicate expression: dir == RightTurn
    In the expression: if dir == RightTurn then 1 else 2
    In the definition of `it': it = if dir == RightTurn then 1 else 2

case whichWay p1 p2 p3 of
       RightTurn   -> <do something>
       _           -> <do something else>

getConvexHull [] = error "there must be at least on point in the list"
getConvexHull (p1:[]) = [p1]
getConvexHull (p1:p2:[]) = [p1, p2]
getConvexHull (p1:p2:p3:[]) = [p1, p2, p3] 
getConvexHull ps =
        let p = getP ps  
            orderedPs = cotanSort p ps 
            p1 = head orderedPs
            p2 = last (take 2 orderedPs)
            p3 = last (take 3 orderedPs)
         in case whichWay p1 p2 p3 of
             RightTurn   -> getConvexHull (head orderedPs : drop 2 orderedPs)
             _           -> head orderedPs : getConvexHull (tail orderedPs)

getConvexHull(tail orderedPs)

p = getP ps

p = getP ps  
orderedPs = cotanSort p ps 

myfunc xs = let a = 2
                b = 3   
                innerFunc _ = xs   --returns the myfunc argument for any call of innerFunc
            in case innerFunc "hello" of   --calls innerFunc and then examines the result
                (x:[])  -> a + b + c 
                _       -> 0    
        where c = 4
 
 
--output:--
*Main> myfunc [3]
9

data A = MyLeft
       | MyRight 
         deriving (Show)
 
myfunc2 xs = innerFunc xs    --call innerFunc with xs as the arg
        where innerFunc (p:ps) =
                case p of
                    MyRight -> 1
                    MyLeft  -> 0
 
--output:--
*Main> myfunc [MyRight]
1

getConvexHull [] = error "there must be at least one point in the list"
getConvexHull (p1:[]) = [p1]
getConvexHull (p1:p2:[]) = [p1, p2]        
getConvexHull ps = helperFunc orderedPs    --call helperFunc
            where p = getP ps  
                  orderedPs = cotanSort p ps   --define orderedPs in the first line
 
                  helperFunc (p1:p2:[]) = [p1, p2]   --define helperFunc in the first line
                  helperFunc xs =
                        let p1 = head xs
                            p2 = last (take 2 xs)
                            p3 = last (take 3 xs)
                        in case whichWay p1 p2 p3 of
                                RightTurn   -> helperFunc (head xs : drop 2 xs)  --eliminate 2nd point from list and try again
                                _           -> head xs : helperFunc (tail xs)  --the first point is on the convex hull so store it 
                                                                               --in a list and get the rest of the convex hull

1) A simple case:
 
*Main> getP [(2, 2), (0,0), (1,0), (3,3)]
(0,0)
 
*Main> cotanSort (0, 0) [(2, 2), (0,0), (1,0), (3,3)]
[(0.0,0.0),(1.0,0.0),(2.0,2.0),(3.0,3.0)]
 
*Main> getConvexHull [(2, 2), (0,0), (1,0), (3,3)]
[(0.0,0.0),(1.0,0.0),(3.0,3.0)]
 
 
 
2) Points with lots of twists and turns:
*Main> getP [(0,5), (3,3), (2, 2), (-5, 1), (0, 3), (2, 3), (0, 0), (1, 0), (2, 5)]
(0,0)
 
*Main> cotanSort (0, 0) [(0,5), (3,3), (2, 2), (-5, 1), (0, 3), (2, 3), (0, 0), (1, 0), (2, 5)]
[(0.0,0.0),(1.0,0.0),(2.0,2.0),(3.0,3.0),(2.0,3.0),(2.0,5.0),(0.0,3.0),(0.0,5.0),(-5.0,1.0)]
 
*Main> getConvexHull [(0,5), (3,3), (2, 2), (-5, 1), (0, 3), (2, 3), (0, 0), (1, 0), (2, 5)]
[(0.0,0.0),(1.0,0.0),(3.0,3.0),(2.0,5.0),(0.0,5.0),(-5.0,1.0)]

getConvexHull [] = error "there must be at least one point in the list"
getConvexHull (p1:[]) = [p1]
getConvexHull (p1:p2:[]) = [p1, p2]        
getConvexHull ps = helperFunc [] orderedPs
    where p = getP ps --defines p used in next line 
          orderedPs = cotanSort p ps --defines orderedPs in first line
 
          --defines helperFunc in first line:
          helperFunc hullPoints (p1:p2:[]) = hullPoints ++ [p1, p2] --Ending condition.  If there are only two points left,
                                                                    --they are both on the convex hull.
          helperFunc hullPoints remainingPoints =                 
              let p1 = head remainingPoints
                  p2 = last (take 2 remainingPoints)
                  p3 = last (take 3 remainingPoints)
              in case whichWay p1 p2 p3 of
                        RightTurn   -> helperFunc hullPointsMinusLast lastConsRemainingPoints 
                        _           -> helperFunc (hullPoints ++ [p1]) (tail remainingPoints)
 
                  where hullPointsMinusLast = if length hullPoints == 0 || length hullPoints == 1
                                              then [] 
                                              else take (length hullPoints - 1) hullPoints
                        remainingPointsMinus2nd = head remainingPoints : drop 2 remainingPoints   
                        lastConsRemainingPoints = last hullPoints : remainingPointsMinus2nd

hullPoints ++ recursiveFunc

helperFunc hullPoints (p1:p2:[]) =

helperFunc hullPoints (p1:p2:[]) = hullPoints ++ [p1, p2]

data MyList a = Cons a (MyList a)
              | Nil
                deriving(Show)

haskToMyList (x:xs) = Cons x (haskToMyList xs)
haskToMyList [] = Nil

Cons "d" (Cons "u" (Cons "r" (Cons "i" (Cons "a" (Cons "n" Nil)))))

myListToHask (Cons first theRest) = first:(myListToHask theRest)
myListToHask Nil = [] 

--sample output:--
 
*Main> :load hask1.hs 
[1 of 1] Compiling Main             ( hask1.hs, interpreted )
Ok, modules loaded: Main.
*Main> let my_list = haskToMyList [10, 20, 30]
*Main> my_list
Cons 10 (Cons 20 (Cons 30 Nil))
*Main> myListToHask my_list
[10,20,30]
*Main> let my_list = haskToMyList "hello"
*Main> my_list
Cons 'h' (Cons 'e' (Cons 'l' (Cons 'l' (Cons 'o' Nil))))
*Main> myListToHask my_list
"hello"
*Main> 

data Tree a = Node a (Maybe (Tree a)) (Maybe (Tree a))
            deriving(Show)

Node a (Maybe (Tree a)) (Maybe (Tree a))

a, Maybe (Tree a), Maybe (Tree a)

Just(Node <args>)

Just(Node 12 Nothing Nothing)

ghci> Book 0 "The Book of Imaginary Beings" ["Jorge Luis Borges"]
Book 0 "The Book of Imaginary Beings" ["Jorge Luis Borges"]

--sample output:--
*Main> let left_leaf = Node 12 Nothing Nothing
*Main> let right_leaf = Node 14 Nothing Nothing
*Main> let left_tree = Just(left_leaf)
*Main> let right_tree = Just(right_leaf)
*Main> let my_tree = Node 12 left_tree right_tree
*Main> my_tree
Node 12 (Just (Node 12 Nothing Nothing)) (Just (Node 14 Nothing Nothing))
*Main>