;; Christian Bouwense

#lang racket
(require eopl/eopl)


;;;;;;;;;;;;;;;;
;; Exercise 1 ;;
;;;;;;;;;;;;;;;;


;; 1.
;;
;; Terminals: n
;; Nonterminals: <Number>, <E>

;; 2.
;;
;; <Number> -> n
;; <E> -> <Number>
;; <E> -> <E> + <E>
;; <E> -> <E> - <E>
;; <E> -> (<E>)

;; 3.
;;
;; <E> -> <E> + <E>
;; <E> + <E> -> <E> + (<E>)
;; <E> + (<E>) -> <E> + (<E> - <E>)
;; <E> + (<E> - <E>) -> <Number> + (<Number> - <Number>)
;; <Number> + (<Number> - <Number>) -> 1 + (4 - 7)

;; 4.
;;
;; 1
;; 1 + 1
;; (1 + 1)


;;;;;;;;;;;;;;;;
;; Exercise 2 ;;
;;;;;;;;;;;;;;;;


;; <SimpleBTree> -> {*<SimpleBTree><SimpleBTree>*}
;; {*<SimpleBTree><SimpleBTree>*} -> {*<SimpleBTree>{*<SimpleBTree><SimpleBTree>*}*}
;; {*<SimpleBTree>{*<SimpleBTree><SimpleBTree>*}*} -> {*2{*3 4*}*}


;;;;;;;;;;;;;;;;
;; Exercise 3 ;;
;;;;;;;;;;;;;;;;


;; Literally how
;(define-datatype ex1 ex1?
;  (Number (num number?))
;  (E (e E?)))


;;;;;;;;;;;;;;;;
;; Exercise 4 ;;
;;;;;;;;;;;;;;;;


(define-datatype Coordinate Coordinate?
  (coord (x number?) (y number?)))

;; coord -> num
(define (getX c)
  (cases Coordinate c
    (coord (x y) x)))

;; Coordinate -> num
(define (getY c)
  (cases Coordinate c
    (coord (x y) y)))

;; {Coordinate, Coordinate} -> num
(define (distance c1 c2)
  (sqrt (- (+ (expt (getX c1) 2) (expt (getX c2) 2))
           (+ (expt (getY c1) 2) (expt (getY c2) 2)))))

(define-datatype Shape Shape?
  (circle (radius number?))
  (rectangle (width number?) (height number?)))

;; Shape -> num
(define (area s)
  (cases Shape s
    (circle (r) (* 3.14 (expt r 2)))
    (rectangle (w h) (* w h))))

;; Shape -> num
(define (perimeter s)
  (cases Shape s
    (circle (r) (* 6.28 r))
    (rectangle (w h) (+ (* 2 w) (* 2 h)))))

;; I didn't do the rest of Exercise 4 because I got the point


;;;;;;;;;;;;;;;;
;; Exercise 5 ;;
;;;;;;;;;;;;;;;;


(define-datatype SimpleBTree SimpleBTree?
  (leaf-t
    (data number?))
  (node-t
    (left SimpleBTree?)
    (right SimpleBTree?)))

;; 1.
;;
;; (node-t (leaf-t 2) (node-t (leaf-t 3) (leaf-t 4)))

;; SimpleBTree? -> bool
(define (isNode t)
  (cases SimpleBTree t
    (node-t (l r) #t)
    (leaf-t (d) #f)))

;; SimpleBTree? -> bool
(define (isLeaf t)
  (cases SimpleBTree t
    (node-t (l r) #f)
    (leaf-t (d) #t)))

;; I don't want to do the rest of this
;; It's just time consuming


;;;;;;;;;;;;;;;;
;; Exercise 6 ;;
;;;;;;;;;;;;;;;;


(define-datatype BTree BTree?
  (leaf-t2 (data number?))
  (node-t2 (data number?)
          (left BTree?)
          (right BTree?)))

;; An example of a BTree
(define ex
  (node-t2 2
          (node-t2 12 (leaf-t2 7) (leaf-t2 11))
          (node-t2 4 (leaf-t2 1) (leaf-t2 9))))

;; 1.
;;
;; BTrees have data in their nodes while SimpleBTrees do not.

;; 2.
;;
;; No.

;; 3.
;;
;; You will get an error, because car is expecting a type pair
;; and ex is of type BTree.

;; 4.
;;
;; (list? ex) will return false.

;; 5.
;;
;; (BTree? ex) will return true.

;; 6.
;;
;; ex is of type BTree.


;;;;;;;;;;;;;;;;
;; Exercise 7 ;;
;;;;;;;;;;;;;;;;


;; Inorder: left -> root -> right
(define (inorder t)
  (cases BTree t
    [node-t2 (d l r)
             (append (inorder l) (cons d (inorder r)))]
    [leaf-t2 (d)
             (list d)]))

;; Preorder: root -> left -> right
(define (preorder t)
  (cases BTree t
    [node-t2 (d l r)
              (cons d (append (preorder l) (preorder r)))]
    [leaf-t2 (d)
              (list d)]))

;; Postorder: left -> right -> root
(define (postorder t)
  (cases BTree t
    [node-t2 (d l r)
              (append (append (postorder l) (postorder r)) (list d))]
    [leaf-t2 (d)
              (list d)]))


;; The rest of the exercises seem like a waste of time.


;;;;;;;;;;;;;
;; Helpers ;;
;;;;;;;;;;;;;


(define sbt1 (leaf-t 1))
(define sbt2 (node-t (leaf-t 1) (leaf-t 2)))

(define bt1 (node-t2 6
               (node-t2 2 (leaf-t2 1)
                          (node-t2 4 (leaf-t2 3)
                                     (leaf-t2 5)))
               (node-t2 7 (leaf-t2 8) (leaf-t2 9))))