Exercise 2.3 make-rectangle 1.rkt

#lang racket

; Exercise 2.3.  Implement a representation for rectangles in a plane. (Hint: You may want to
; make use of exercise 2.2.) In terms of your constructors and selectors, create procedures
; that compute the perimeter and the area of a given rectangle. Now implement a different
; representation for rectangles. Can you design your system with suitable abstraction
; barriers, so that the same perimeter and area procedures will work using either
; representation?

; SOLUTION

; Perimeter of Rectangle
(define (perimeter-rect r)
	(* 2 (+ (dim1-rect r) (dim2-rect r)))
)

; Area of Rectangle
(define (area-rect r)
	(* (dim1-rect r) (dim2-rect r))
)

; Print Rectangle
(define (print-rect r)
	(display "[")
	(print-point (start-segment (diag1-rect r)))
	(display " ")
	(print-point (end-segment (diag2-rect r)))
	(display " ")
	(print-point (end-segment (diag1-rect r)))
	(display " ")
	(print-point (start-segment (diag2-rect r)))
	(display "]")
)

; Rectangle Construction from two line segments which are the diagonals
; The segments have to be equal in length and should bisect-each other.
; Otherwise it will be an error
(define (make-rect diag1 diag2)
	; Check for validity first
	(cond
		; length check
		((not (= (length-of-segment diag1) (length-of-segment diag2)))
		 (error "Invalid Input: Segments have unequal lengths"))
		; coincidence of mid-point check
		((not (points-equal? (midpoint-segment diag1) (midpoint-segment diag2)))
		 (error "Invalid Input: Mid-points of segments don't coincide"))
		; the two segments should not be the same
		((segments-same? diag1 diag2) (error "Invalid Input: Segments are the same"))
		(else
			(cons diag1 diag2)
		)
	)
)

; Rectangle Selectors (return the two sides of the rectangle)
(define (dim1-rect r)
	; distance from 'start' of diag1 to 'start' of diag2
	(length-of-segment (make-segment (start-segment (car r)) (start-segment (cdr r))))
)

(define (dim2-rect r)
	; distance from 'start' of diag1 to 'end' of diag2
	(length-of-segment (make-segment (start-segment (car r)) (end-segment (cdr r))))
)

(define (diag1-rect r)
	(car r)
)

(define (diag2-rect r)
	(cdr r)
)

; Mid-point of a segment
(define (midpoint-segment line-segment)
	(make-point 
		(/ (+ (x-point (start-segment line-segment)) (x-point (end-segment line-segment))) 2)
		(/ (+ (y-point (start-segment line-segment)) (y-point (end-segment line-segment))) 2)
	)
)

; Line Segment Constructor
(define (make-segment start-segment end-segment)
	(cons start-segment end-segment)
)

; Line Segment Selectors
(define (start-segment segment)
	(car segment)
)

(define (end-segment segment)
	(cdr segment)
)

; Line Segment length
(define (length-of-segment segment)
	(sqrt
		(+
			(square (- (x-point (end-segment segment)) (x-point (start-segment segment))))
			(square (- (y-point (end-segment segment)) (y-point (start-segment segment))))
		)
	)
)

; Comparing two segments
(define (segments-same? segment1 segment2)
	(or
		(and (points-equal? (start-segment segment1) (start-segment segment2)) (points-equal? (end-segment segment1) (end-segment segment2)))
		(and (points-equal? (start-segment segment1) (end-segment segment2)) (points-equal? (end-segment segment1) (start-segment segment2)))
	)
)

; Point Constructor
(define (make-point x-coord y-coord)
	(cons x-coord y-coord)
)

; Point Selectors
(define (x-point point)
	(car point)
)

(define (y-point point)
	(cdr point)
)

; Equality of two points (i.e. are two points the same?)
(define (points-equal? point1 point2)
	(and (= (x-point point1) (x-point point2)) (= (y-point point1) (y-point point2)))
)

(define (print-point p)
	; (newline)
	(display "(")
	(display (x-point p))
	(display ",")
	(display (y-point p))
	(display ")")
)

(define (square x)
	(* x x)
)

; Tests

Welcome to DrRacket, version 6.9 [3m].
Language: racket, with debugging; memory limit: 512 MB.
> (make-point 1 1)
'(1 . 1)
> (define a (make-point 1 1))
> a
'(1 . 1)
> (define b (make-point 11 1))
> (define c (make-point 11 7))
> (define d (make-point 1 7))
> a
'(1 . 1)
> b
'(11 . 1)
> c
'(11 . 7)
> d
'(1 . 7)
> (define diag1 (make-segment a c))
> (define diag2 (make-segment d b))
> (define r (make-rect diag1 diag2))
> (perimeter-rect r)
32
> (area-rect r)
60
> (define m (make-point 5 0))
> (define n (make-point 22 17))
> (define o (make-point 17 22))
> (define p (make-point 0 5))
> m
'(5 . 0)
> n
'(22 . 17)
> o
'(17 . 22)
> p
'(0 . 5)
> (define diag1 (make-segment m o))
> (define diag2 (make-segment p n))
> (define r (make-rect diag1 diag2))
> (perimeter-rect r)
62.22539674441618
> (area-rect r)
170.0
> (dim1-rect r)
7.0710678118654755
> (dim2-rect r)
24.041630560342615
> (* (dim1-rect r) (dim2-rect r))
170.0
> (define w (make-point 0 0))
> (define x (make-point 4 4))
> (define y (make-point 10 3))
> (define z (make-point -10 7))
> (make-rect (make-segment w y) (make-segment z x))
Invalid Input: Segments have unequal lengths
> (define a (make-point 4 4))
> (define b (make-point 4 10))
> (define c (make-point 4 10))
> (define d (make-point 4 4))
> (define r (make-rect (make-segment a c) (make-segment d b)))
Invalid Input: Segments are the same

> (define a (make-point 5 0))
> (define b (make-point 0 5))
> (define c (make-point 0 -5))
> (define c (make-point -5 0))
> (define d (make-point 0 -5))
> (define r (make-rect (make-segment a c) (make-segment b d)))
> (perimeter-rect r)
28.284271247461902
> (area-rect r)
50.00000000000001
> (define d (make-point 0 -6))
> (define r (make-rect (make-segment a c) (make-segment b d)))
. . Invalid Input: Segments have unequal lengths
> (define a (make-point 6 0))
> (define r (make-rect (make-segment a c) (make-segment b d)))
. . Invalid Input: Mid-points of segments don't coincide

> (define a (make-point 2 0))
> (define b (make-point 0 2))
> (define c (make-point -2 0))
> (define d (make-point 0 -2))
> (define r (make-rect (make-segment a c) (make-segment b d)))
> (perimeter-rect r)
11.313708498984761
> (area-rect r)
8.000000000000002
> (define r (make-rect (make-segment a c) (make-segment d b)))
> (perimeter-rect r)
11.313708498984761
> (area-rect r)
8.000000000000002
> (define r (make-rect (make-segment c a) (make-segment b d)))
> (perimeter-rect r)
11.313708498984761
> (area-rect r)
8.000000000000002
> (define r (make-rect (make-segment c a) (make-segment d b)))
> (perimeter-rect r)
11.313708498984761
> (area-rect r)
8.000000000000002
>