Project 3

project-2/step0.bak

@@ -0,0 +1,16 @@
+(define (point x y)
+  (define (dispatch m)
+    (cond ((eq? m 'getx) x)
+          ((eq? m 'gety) y)
+          ((eq? m 'type) 'point)
+          ((eq? m 'info) (list 'point x y))
+          (else (display (string-append "point as no method: " (symbol->string m) "\n")))))
+  dispatch)
+(define p (point 1 2))
+(p 'getx) ; 1
+(p 'gety) ; 2
+(p 'type) ; point
+(p 'info) ; (point 1 2)
+(p 'foo) ; display "point as no method: foo
+
+

project-2/step0.rkt

@@ -0,0 +1,25 @@
+;Auhors:Dubois Brieuc, Dubois Simon
+;Addapted from the example given in the assignment. Major change are:
+;   function directly defined in dispatch
+;   = changed to eq? to take symbol as input
+;   eror message added
+
+;Class definition
+(define (point x y)
+  (define (dispatch m)
+    (cond ((eq? m 'getx) x)
+          ((eq? m 'gety) y)
+          ((eq? m 'type) 'point)
+          ((eq? m 'info) (list 'point x y))
+          (else (display (string-append "point as no method: " (symbol->string m) "\n")))))
+  dispatch)
+
+;Usage example 
+(define p (point 1 2))
+(p 'getx) ; 1
+(p 'gety) ; 2
+(p 'type) ; point
+(p 'info) ; (point 1 2)
+(p 'foo) ; display "point as no method: foo"
+
+

project-2/step1.bak

@@ -0,0 +1,34 @@
+(define (point x y)
+  (define (self m)
+    (cond ((eq? m 'getx) (lambda () x))
+          ((eq? m 'gety) (lambda () y))
+          ((eq? m 'type) (lambda () 'point))
+          ((eq? m 'setx!) (lambda (nx) (set! x nx)))
+          ((eq? m 'sety!) (lambda (ny) (set! y ny)))
+          ((eq? m 'info) (lambda () (list 'point x y)))
+          ((eq? m 'add) (lambda (p)
+                          (let ((px ((p 'getx)))
+                                (py ((p 'gety))))
+                            (point (+ x px) (+ y py)))))
+          ((eq? m 'sub) (lambda (p)
+                          (let ((px ((p 'getx)))
+                                (py ((p 'gety))))
+                            (point (- x px) (- y py)))))
+          (else (lambda () (display (string-append "Message not understood: " (symbol->string m) "\n"))))))
+  self)
+
+(define p1 (point 1 2))
+(define p2 (point 3 4))
+((p1 'getx)) ; returns 1
+((p1 'gety)) ; returns 2
+((p2 'getx)) ; returns 3
+((p2 'gety)) ; returns 4
+(define pp ((p1 'add) p2)) ; returns a new point pp
+((pp 'info)) ; returns (point 4 6)
+(define pn ((p1 'sub) p2)) ; returns a new point pn
+((pn 'info)) ; returns (point -2 -2)
+((pp 'foo)) ; should display "Message not understood" error
+((p1 'setx!) 5)
+((p1 'sety!) 5)
+((p1 'info)) ; returns (point 5 5)
+

project-2/step1.rkt

@@ -0,0 +1,40 @@
+;Auhors:Dubois Brieuc, Dubois Simon
+;Added lambda function to allow for aguments in methodes
+;We renamed dispatch as self
+
+;Class definition
+(define (point x y)
+  (define (self m)
+    (cond ((eq? m 'getx) (lambda () x))
+          ((eq? m 'gety) (lambda () y))
+          ((eq? m 'type) (lambda () 'point))
+          ((eq? m 'setx!) (lambda (nx) (set! x nx)))
+          ((eq? m 'sety!) (lambda (ny) (set! y ny)))
+          ((eq? m 'info) (lambda () (list 'point x y)))
+          ((eq? m 'add) (lambda (p)
+                          (let ((px ((p 'getx)))
+                                (py ((p 'gety))))
+                            (point (+ x px) (+ y py)))))
+          ((eq? m 'sub) (lambda (p)
+                          (let ((px ((p 'getx)))
+                                (py ((p 'gety))))
+                            (point (- x px) (- y py)))))
+          (else (lambda () (display (string-append "Message not understood: " (symbol->string m) "\n"))))))
+  self)
+
+;Usage example
+(define p1 (point 1 2))
+(define p2 (point 3 4))
+((p1 'getx)) ; returns 1
+((p1 'gety)) ; returns 2
+((p2 'getx)) ; returns 3
+((p2 'gety)) ; returns 4
+(define pp ((p1 'add) p2)) ; returns a new point pp
+((pp 'info)) ; returns (point 4 6)
+(define pn ((p1 'sub) p2)) ; returns a new point pn
+((pn 'info)) ; returns (point -2 -2)
+((pp 'foo)) ; should display "Message not understood" error
+((p1 'setx!) 5)
+((p1 'sety!) 5)
+((p1 'info)) ; returns (point 5 5)
+

project-2/step2+3a.rkt

@@ -0,0 +1,70 @@
+;Auhors:Dubois Brieuc, Dubois Simon
+;This is the step 2 and step 3a combined
+;Here we extracted the method definitons from the
+;dispatch(self) function. We also implented a send
+;function that allow to request a method from an object
+;an pass it argument.
+
+;Class definition
+(define (point x y)
+  ;Method definition
+  (define (getx) (lambda () x))
+  (define (gety) (lambda () y))
+  (define (type) (lambda () 'point))
+  (define (setx!) (lambda (nx) (set! x nx)))
+  (define (sety!) (lambda (ny) (set! y ny)))
+  (define (info) (lambda () (list 'point x y)))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (+ x px) (+ y py))
+                   )
+                 ))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (- x px) (- y py))
+                   )
+                 ))
+  ;message handeling method
+  (define (self m)
+    (cond ((eq? m 'getx) (getx))
+          ((eq? m 'gety) (gety))
+          ((eq? m 'type) (type))
+          ((eq? m 'setx!) (setx!))
+          ((eq? m 'sety!) (sety!))
+          ((eq? m 'info) (info))
+          ((eq? m 'add) (add))
+          ((eq? m 'sub) (sub))
+          (else (lambda args (display (string-append "Message not understood: " (symbol->string m) "\n"))))))
+  self
+ )
+
+
+(define (method-lookup reciever message)
+  (if (= (length message) 1)
+      ((reciever (car message)))
+      ((reciever (car message)) (car (cdr message)))
+  ))
+
+(define (send reciever . message)
+  (if (procedure? reciever)
+      (method-lookup reciever message)
+      (display (string-append "Inappropriate receiver object: " (symbol->string reciever) "\n"))
+  )
+ )
+
+;Usage example
+(define p1 (point 1 2))
+(define p2 (point 3 4))
+(send p1 'getx) ; 1
+(send p1 'gety) ; 2
+(send p2 'getx) ; 3
+(send p2 'gety) ; 4
+(define p (send p1 'add p2))
+(send p 'info) ; (point 4 6)
+(send 'not-a-point 'info) ; should display "Inappropriate receiver object"
+(send p 'foo) ; should display "Message not understood"
+(send p 'bar 2) ; should display "Message not understood"
+(send p1 'setx! 5)
+(send p1 'getx) ; returns 5

project-2/step2.bak

@@ -0,0 +1,39 @@
+(define (point x y)
+  (define (self m)
+    (cond ((eq? m 'getx) (lambda () x))
+          ((eq? m 'gety) (lambda () y))
+          ((eq? m 'type) (lambda () 'point))
+          ((eq? m 'setx!) (lambda (nx) (set! x nx)))
+          ((eq? m 'sety!) (lambda (ny) (set! y ny)))
+          ((eq? m 'info) (lambda () (list 'point x y)))
+          ((eq? m 'add) (lambda (p)
+                          (let ((px ((p 'getx)))
+                                (py ((p 'gety))))
+                            (point (+ x px) (+ y py)))))
+          ((eq? m 'sub) (lambda (p)
+                          (let ((px ((p 'getx)))
+                                (py ((p 'gety))))
+                            (point (- x px) (- y py)))))
+          (else (lambda () (display (string-append "Message not understood: " (symbol->string m) "\n"))))))
+  self)
+
+(define (send obj . args)
+  (if (procedure? obj)
+      (if (= (length args) 1)
+          ((obj (car args)))
+          ((obj (car args)) (car (cdr args))))  ; Extracting the second argument
+      (display (string-append "Inappropriate receiver object: " (symbol->string obj) "\n"))))
+
+(define p1 (point 1 2))
+(define p2 (point 3 4))
+(send p1 'getx) ; 1
+(send p1 'gety) ; 2
+(send p2 'getx) ; 3
+(send p2 'gety) ; 4
+(define p (send p1 'add p2))
+(send p 'info) ; (point 4 6)
+(send 'not-a-point 'info) ; should display "Inappropriate receiver object"
+(send p 'foo) ; should display "Message not understood"
+(send p 'bar 2) ; should display "Message not understood"
+(send p1 'setx! 5)
+(send p1 'getx) ; returns 5

project-2/step2.rkt

@@ -0,0 +1,39 @@
+(define (point x y)
+  (define (self m)
+    (cond ((eq? m 'getx) (lambda () x))
+          ((eq? m 'gety) (lambda () y))
+          ((eq? m 'type) (lambda () 'point))
+          ((eq? m 'setx!) (lambda (nx) (set! x nx)))
+          ((eq? m 'sety!) (lambda (ny) (set! y ny)))
+          ((eq? m 'info) (lambda () (list 'point x y)))
+          ((eq? m 'add) (lambda (p)
+                          (let ((px ((p 'getx)))
+                                (py ((p 'gety))))
+                            (point (+ x px) (+ y py)))))
+          ((eq? m 'sub) (lambda (p)
+                          (let ((px ((p 'getx)))
+                                (py ((p 'gety))))
+                            (point (- x px) (- y py)))))
+          (else (lambda () (display (string-append "Message not understood: " (symbol->string m) "\n"))))))
+  self)
+
+(define (send obj . args)
+  (if (procedure? obj)
+      (if (= (length args) 1)
+          ((obj (car args)))
+          ((obj (car args)) (car (cdr args))))  ; Extracting the second argument
+      (display (string-append "Inappropriate receiver object: " (symbol->string obj) "\n"))))
+
+(define p1 (point 1 2))
+(define p2 (point 3 4))
+(send p1 'getx) ; 1
+(send p1 'gety) ; 2
+(send p2 'getx) ; 3
+(send p2 'gety) ; 4
+(define p (send p1 'add p2))
+(send p 'info) ; (point 4 6)
+(send 'not-a-point 'info) ; should display "Inappropriate receiver object"
+(send p 'foo) ; should display "Message not understood"
+(send p 'bar 2) ; should display "Message not understood"
+(send p1 'setx! 5)
+(send p1 'getx) ; returns 5

project-2/step3.bak

@@ -0,0 +1,66 @@
+(define (point x y)
+  (define (getx) (lambda () x))
+  (define (gety) (lambda () y))
+  (define (type) (lambda () 'point))
+  (define (setx!) (lambda (nx) (set! x nx)))
+  (define (sety!) (lambda (ny) (set! y ny)))
+  (define (info) (lambda () (list 'point x y)))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (+ x px) (+ y py))
+                   )
+                 ))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (- x px) (- y py))
+                   )
+                 ))
+  (define (self m)
+    (cond ((eq? m 'getx) (getx))
+          ((eq? m 'gety) (gety))
+          ((eq? m 'type) (type))
+          ((eq? m 'setx!) (setx!))
+          ((eq? m 'sety!) (sety!))
+          ((eq? m 'info) (info))
+          ((eq? m 'add) (add))
+          ((eq? m 'sub) (sub))
+          (else (lambda args (display (string-append "Message not understood: " (symbol->string m) "\n"))))))
+  self
+ )
+
+(define (send2 obj . args)
+  (if (procedure? obj)
+      (if (= (length args) 1)
+          ((obj (car args)))
+          ((obj (car args)) (car (cdr args))))  ; Extracting the second argument
+      (display (string-append "Inappropriate receiver object: " (symbol->string obj) "\n"))))
+
+(define (method-lookup reciever message)
+  (if (= (length message) 1)
+      ((reciever (car message)))
+      ((reciever (car message)) (car (cdr message)))
+  ))
+
+(define (send reciever . message)
+  (if (procedure? reciever)
+      (method-lookup reciever message)
+      (display (string-append "Inappropriate receiver object: " (symbol->string reciever) "\n"))
+  )
+ )
+
+
+(define p1 (point 1 2))
+(define p2 (point 3 4))
+(send p1 'getx) ; 1
+(send p1 'gety) ; 2
+(send p2 'getx) ; 3
+(send p2 'gety) ; 4
+(define p (send p1 'add p2))
+(send p 'info) ; (point 4 6)
+(send 'not-a-point 'info) ; should display "Inappropriate receiver object"
+(send p 'foo) ; should display "Message not understood"
+(send p 'bar 2) ; should display "Message not understood"
+(send p1 'setx! 5)
+(send p1 'getx) ; returns 5

project-2/step3b.bak

@@ -0,0 +1,114 @@
+(define (object)
+	(define super 'nil)
+	(define (self m)
+		(cond
+			((eq? m 'type) (lambda () 'object))
+		  (else (lambda args (display (string-append "Message not understood: " (symbol->string m) "\n"))))
+		)
+	)
+	self
+)
+
+(define (point x y)
+	(define super (object))
+  (define (getx) (lambda () x))
+  (define (gety) (lambda () y))
+  (define (type) (lambda () 'point))
+  (define (setx!) (lambda (nx) (set! x nx)))
+  (define (sety!) (lambda (ny) (set! y ny)))
+  (define (info) (lambda () (list 'point x y)))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (+ x px) (+ y py))
+                   )
+                 ))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (- x px) (- y py))
+                   )
+                 ))
+
+  (define (self m)
+    (cond ((eq? m 'getx) (getx))
+          ((eq? m 'gety) (gety))
+          ((eq? m 'type) (type))
+          ((eq? m 'setx!) (setx!))
+          ((eq? m 'sety!) (sety!))
+          ((eq? m 'info) (info))
+          ((eq? m 'add) (add))
+          ((eq? m 'sub) (sub))
+		      (else (lambda args (method-lookup super (cons m args))))
+		)
+	)
+  self
+ )
+
+(define (color-point x y color)
+	(define super (point x y))
+	(define (type) (lambda () 'color-point))
+	(define (get-color) (lambda () color))
+	(define (info) (lambda () (append ((super 'info)) (list color))))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (color-point (+ x px) (+ y py) color)
+                   )
+                 ))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (color-point (- x px) (- y py) color)
+                   )
+                 ))
+
+	(define (self m)
+		(cond ((eq? m 'type) (type))
+					((eq? m 'get-color) (get-color))
+					((eq? m 'info) (info))
+					((eq? m 'add) (add))
+		      (else (lambda args (method-lookup super (cons m args))))
+		)
+	)
+	self
+)
+
+(define (method-lookup reciever message)
+  (if (= (length message) 1)
+      ((reciever (car message)))
+      ((reciever (car message)) (car (cdr message)))
+  ))
+
+(define (send reciever . message)
+  (if (procedure? reciever)
+      (method-lookup reciever message)
+      (display (string-append "Inappropriate receiver object: " (symbol->string reciever) "\n"))
+  )
+ )
+
+(define o (object))
+(send o 'type) ; object
+(send o 'foo) ; should display "Message not understood"
+
+(define p1 (point 1 2))
+(define p2 (point 3 4))
+(send p1 'getx) ; 1
+(send p1 'gety) ; 2
+(send p2 'getx) ; 3
+(send p2 'gety) ; 4
+(define p (send p1 'add p2))
+(send p 'info) ; (point 4 6)
+
+(define cp (color-point 5 6 'red))
+(send cp 'type) ; color−point
+(send cp 'getx) ; 5
+(send cp 'gety) ; 6
+(send cp 'get-color) ; red
+(send cp 'info)
+
+(define cp−1 (send cp 'add (color-point 1 2 'green)))
+(send cp−1 'type) ; color−point
+(send cp−1 'getx) ; 6
+(send cp−1 'gety) ; 8
+(send cp−1 'get-color) ; red

project-2/step3b.rkt

@@ -0,0 +1,118 @@
+;Auhors:Dubois Brieuc, Dubois Simon
+;Here we intoduced inheritance by creating a basic object class that work as parent class for all other class
+;We also created the class color point inheriting from the class point
+(define (object)
+	(define super 'nil)
+	(define (self m)
+		(cond
+			((eq? m 'type) (lambda () 'object))
+		  (else (lambda args (display (string-append "Message not understood: " (symbol->string m) "\n"))))
+		)
+	)
+	self
+)
+
+(define (point x y)
+	(define super (object))
+  (define (getx) (lambda () x))
+  (define (gety) (lambda () y))
+  (define (type) (lambda () 'point))
+  (define (setx!) (lambda (nx) (set! x nx)))
+  (define (sety!) (lambda (ny) (set! y ny)))
+  (define (info) (lambda () (list 'point x y)))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (+ x px) (+ y py))
+                   )
+                 ))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (- x px) (- y py))
+                   )
+                 ))
+
+  (define (self m)
+    (cond ((eq? m 'getx) (getx))
+          ((eq? m 'gety) (gety))
+          ((eq? m 'type) (type))
+          ((eq? m 'setx!) (setx!))
+          ((eq? m 'sety!) (sety!))
+          ((eq? m 'info) (info))
+          ((eq? m 'add) (add))
+          ((eq? m 'sub) (sub))
+		      (else (lambda args (method-lookup super (cons m args))))
+		)
+	)
+  self
+ )
+
+(define (color-point x y color)
+	(define super (point x y))
+	(define (type) (lambda () 'color-point))
+	(define (get-color) (lambda () color))
+	(define (info) (lambda () (append ((super 'info)) (list color))))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (color-point (+ x px) (+ y py) color)
+                   )
+                 ))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (color-point (- x px) (- y py) color)
+                   )
+                 ))
+
+	(define (self m)
+		(cond ((eq? m 'type) (type))
+					((eq? m 'get-color) (get-color))
+					((eq? m 'info) (info))
+					((eq? m 'add) (add))
+		      (else (lambda args (method-lookup super (cons m args))))
+		)
+	)
+	self
+)
+
+(define (method-lookup reciever message)
+  (if (= (length message) 1)
+      ((reciever (car message)))
+      ((reciever (car message)) (car (cdr message)))
+  ))
+
+(define (send reciever . message)
+  (if (procedure? reciever)
+      (method-lookup reciever message)
+      (display (string-append "Inappropriate receiver object: " (symbol->string reciever) "\n"))
+  )
+ )
+
+;Usage example
+(define o (object))
+(send o 'type) ; object
+(send o 'foo) ; should display "Message not understood"
+
+(define p1 (point 1 2))
+(define p2 (point 3 4))
+(send p1 'getx) ; 1
+(send p1 'gety) ; 2
+(send p2 'getx) ; 3
+(send p2 'gety) ; 4
+(define p (send p1 'add p2))
+(send p 'info) ; (point 4 6)
+
+(define cp (color-point 5 6 'red))
+(send cp 'type) ; color−point
+(send cp 'getx) ; 5
+(send cp 'gety) ; 6
+(send cp 'get-color) ; red
+(send cp 'info)
+
+(define cp−1 (send cp 'add (color-point 1 2 'green)))
+(send cp−1 'type) ; color−point
+(send cp−1 'getx) ; 6
+(send cp−1 'gety) ; 8
+(send cp−1 'get-color) ; red

project-2/step4.bak

@@ -0,0 +1,118 @@
+(define (object)
+	(define super 'nil)
+	(define self 'nil)
+	(define (set-self!) (lambda (s) (set! self s)))
+	(define (internal m)
+		(cond
+			((eq? m 'type) (lambda () 'object))
+			((eq? m 'info) (lambda () (list (send self 'type))))
+			((eq? m 'set-self!) (set-self!))
+		  (else (lambda args (display (string-append "Message not understood: " (symbol->string m) "\n"))))
+		)
+	)
+	internal
+)
+
+(define (point x y)
+	(define super (object))
+	(define self 'nil)
+	(define (set-self!) (lambda (s)
+		 (set! self s)
+		 (method-lookup super (list 'set-self! s))
+	))
+  (define (getx) (lambda () x))
+  (define (gety) (lambda () y))
+  (define (type) (lambda () 'point))
+  (define (setx!) (lambda (nx) (set! x nx)))
+  (define (sety!) (lambda (ny) (set! y ny)))
+  (define (info) (lambda () (append ((super 'info)) (list x))))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (+ x px) (+ y py))
+                   )
+                 ))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (- x px) (- y py))
+                   )
+                 ))
+
+  (define (internal m)
+    (cond ((eq? m 'set-self!) (set-self!))
+          ((eq? m 'type) (type))
+					((eq? m 'getx) (getx))
+          ((eq? m 'gety) (gety))
+          ((eq? m 'setx!) (setx!))
+          ((eq? m 'sety!) (sety!))
+          ((eq? m 'info) (info))
+          ((eq? m 'add) (add))
+          ((eq? m 'sub) (sub))
+		      (else (lambda args (method-lookup super (list m args))))
+		)
+	)
+  internal
+ )
+
+(define (color-point x y color)
+	(define super (point x y))
+	(define self 'nil)
+	(define (set-self!) (lambda (s)
+		 (set! self s)
+		 (method-lookup super (list 'set-self! s))
+	))
+	(define (type) (lambda () 'color-point))
+	(define (get-color) (lambda () color))
+	(define (info) (lambda () (append ((super 'info)) (list color))))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (color-point (+ x px) (+ y py) color)
+                   )
+                 ))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (color-point (- x px) (- y py) color)
+                   )
+                 ))
+
+	(define (internal m)
+		(cond ((eq? m 'set-self!) (set-self!))
+					((eq? m 'type) (type))
+					((eq? m 'get-color) (get-color))
+					((eq? m 'info) (info))
+					((eq? m 'add) (add))
+		      (else (lambda args (method-lookup super (cons m args))))
+		)
+	)
+	internal
+)
+
+(define (method-lookup reciever message)
+  (if (= (length message) 1)
+      ((reciever (car message)))
+      ((reciever (car message)) (car (cdr message)))
+  ))
+
+(define (send reciever . message)
+  (if (procedure? reciever)
+      (method-lookup reciever message)
+      (display (string-append "Inappropriate receiver object: " (symbol->string reciever) "\n"))
+  )
+ )
+
+(define (new cls . args)
+	(let ((object (apply cls args)))
+		(send object 'set-self! object)
+		object
+	)
+)
+
+(define cp (new color-point 5 6 'red))
+(send cp 'type) ; color−point
+(send cp 'getx) ; 5
+(send cp 'gety) ; 6
+(send cp 'get-color) ; red
+(send cp 'info) ; (color−point 5 6 red

project-2/step4.rkt

@@ -0,0 +1,121 @@
+;Auhors:Dubois Brieuc, Dubois Simon
+;Here we intoduced the dynamic binding of self. We added the new method allowing to create new instance of a class.
+(define (object)
+	(define super 'nil)
+	(define self 'nil)
+	(define (set-self!) (lambda (s) (set! self s)))
+	(define (internal m)
+		(cond
+			((eq? m 'type) (lambda () 'object))
+			((eq? m 'info) (lambda () (list (send self 'type))))
+			((eq? m 'set-self!) (set-self!))
+		  (else (lambda args (display (string-append "Message not understood: " (symbol->string m) "\n"))))
+		)
+	)
+	internal
+)
+
+(define (point x y)
+	(define super (object))
+	(define self 'nil)
+	(define (set-self!) (lambda (s)
+		 (set! self s)
+		 (method-lookup super (list 'set-self! s))
+	))
+  (define (getx) (lambda () x))
+  (define (gety) (lambda () y))
+  (define (type) (lambda () 'point))
+  (define (setx!) (lambda (nx) (set! x nx)))
+  (define (sety!) (lambda (ny) (set! y ny)))
+  (define (info) (lambda () (append ((super 'info)) (list x y))))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (+ x px) (+ y py))
+                   )
+                 ))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (- x px) (- y py))
+                   )
+                 ))
+
+  (define (internal m)
+    (cond ((eq? m 'set-self!) (set-self!))
+          ((eq? m 'type) (type))
+					((eq? m 'getx) (getx))
+          ((eq? m 'gety) (gety))
+          ((eq? m 'setx!) (setx!))
+          ((eq? m 'sety!) (sety!))
+          ((eq? m 'info) (info))
+          ((eq? m 'add) (add))
+          ((eq? m 'sub) (sub))
+		      (else (lambda args (method-lookup super (list m args))))
+		)
+	)
+  internal
+ )
+
+(define (color-point x y color)
+	(define super (point x y))
+	(define self 'nil)
+	(define (set-self!) (lambda (s)
+		 (set! self s)
+		 (method-lookup super (list 'set-self! s))
+	))
+	(define (type) (lambda () 'color-point))
+	(define (get-color) (lambda () color))
+	(define (info) (lambda () (append ((super 'info)) (list color))))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (color-point (+ x px) (+ y py) color)
+                   )
+                 ))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (color-point (- x px) (- y py) color)
+                   )
+                 ))
+
+	(define (internal m)
+		(cond ((eq? m 'set-self!) (set-self!))
+					((eq? m 'type) (type))
+					((eq? m 'get-color) (get-color))
+					((eq? m 'info) (info))
+					((eq? m 'add) (add))
+		      (else (lambda args (method-lookup super (cons m args))))
+		)
+	)
+	internal
+)
+
+(define (method-lookup reciever message)
+  (if (= (length message) 1)
+      ((reciever (car message)))
+      ((reciever (car message)) (car (cdr message)))
+  ))
+
+(define (send reciever . message)
+  (if (procedure? reciever)
+      (method-lookup reciever message)
+      (display (string-append "Inappropriate receiver object: " (symbol->string reciever) "\n"))
+  )
+ )
+
+(define (new cls . args)
+	(let ((object (apply cls args)))
+		(send object 'set-self! object)
+		object
+	)
+)
+
+;Usage example
+(define cp (new color-point 5 6 'red))
+(send cp 'type) ; color−point
+(send cp 'getx) ; 5
+(send cp 'gety) ; 6
+(send cp 'get-color) ; red
+(send cp 'info) ; (color−point 5 6 red)

project-2/step5_attempt.rkt

@@ -0,0 +1,59 @@
+(define-syntax define-class
+  (syntax-rules ()
+    ((_ (class-name . args) body ...)
+     (let ()
+       (define (class-name . args)
+         (let ((self ()))
+           (define (dispatch m)
+             (cond
+               ((eq? m 'self) self)
+               ((eq? m 'type) (lambda () 'class-name))
+               ((eq? m 'init)
+                (lambda args
+                  (set! self (apply class-name args))
+                  self))
+               ((eq? m 'dispatch) dispatch)
+               (else (error "Unknown method" m)))))
+           body ...
+           dispatch)))))
+
+(define-class (object)
+  (define super 'nil)
+  (define (self m)
+    (cond
+      ((eq? m 'type) (lambda () 'object))
+      (else (lambda args (display (string-append "Message not understood: " (symbol->string m) "\n")))))))
+  
+(define-class (point x y)
+  (define (getx) (lambda () x))
+  (define (gety) (lambda () y))
+  (define (type) (lambda () 'point))
+  (define (setx!) (lambda (nx) (set! x nx)))
+  (define (sety!) (lambda (ny) (set! y ny)))
+  (define (info) (lambda () (list 'point x y)))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (+ x px) (+ y py)))))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (point (- x px) (- y py))))))
+
+(define-class (color-point x y color)
+  (define (type) (lambda () 'color-point))
+  (define (get-color) (lambda () color))
+  (define (info) (lambda () (append ((super 'info)) (list color))))
+  (define (add) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (color-point (+ x px) (+ y py) color))))
+  (define (sub) (lambda (p)
+                  (let ((px ((p 'getx)))
+                        (py ((p 'gety))))
+                    (color-point (- x px) (- y py) color)))))
+
+(define (send receiver . message)
+  (if (procedure? receiver)
+      ((receiver 'dispatch) message)
+      (display (string-append "Inappropriate receiver object: " (symbol->string receiver) "\n"))))

project-3/regex/code/code1.py

@@ -0,0 +1,15 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    var_3 = 0
+    while var_2 <= var_1 :
+        var_4 = ((-1)**var_2)/((2*var_2) +1)
+        var_3 += 4*var_4
+        var_2+=1
+    return var_3
+    print(var_3)

project-3/regex/code/code10.py

@@ -0,0 +1,16 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 13
+    i = 7
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    n = 0
+    pi = 0
+    while n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    return pi
+    print(pi)

project-3/regex/code/code100.py

@@ -0,0 +1,6 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    print(sum)

project-3/regex/code/code1000.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if var_1 == 0:
+        return 4
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print((4*var_2))
+    return(4*var_2)

project-3/regex/code/code1001.py

@@ -0,0 +1,11 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    print(4*pi)

project-3/regex/code/code1002.py

@@ -0,0 +1,10 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    print(4*pi)

project-3/regex/code/code1003.py

@@ -0,0 +1,10 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_1) / ((2*var_1)+1))
+    print(4*var_2)

project-3/regex/code/code1004.py

@@ -0,0 +1,5 @@
+def approx_pi(i):        
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    print(4*pi)

project-3/regex/code/code1005.py

@@ -0,0 +1,6 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)
+    print((4*var_2))

project-3/regex/code/code1006.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print(4*var_2)

project-3/regex/code/code1007.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)

project-3/regex/code/code1008.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+        return(4*var_2)

project-3/regex/code/code1009.py

@@ -0,0 +1,6 @@
+def approx_pi(var_1):        
+    var_1 = 2
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)

project-3/regex/code/code101.py

@@ -0,0 +1,6 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1010.py

@@ -0,0 +1,6 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print((4*var_2))
+    return(4*var_2)

project-3/regex/code/code1011.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)

project-3/regex/code/code1012.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)

project-3/regex/code/code1013.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+        return(4*pi)

project-3/regex/code/code1014.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    print(4*pi)

project-3/regex/code/code1015.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    return(4*pi)

project-3/regex/code/code1016.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    i = 16
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    return(4*pi)

project-3/regex/code/code1017.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    return(4*pi)
+    print((4*pi))

project-3/regex/code/code1018.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    print((4*pi))
+    return(4*pi)

project-3/regex/code/code1019.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    return(4*pi)

project-3/regex/code/code102.py

@@ -0,0 +1,6 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1020.py

@@ -0,0 +1,7 @@
+def approx_pi(var_1):        
+    if var_1 == 0:
+        print(4)
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)

project-3/regex/code/code1021.py

@@ -0,0 +1,22 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if var_1 == 0:
+        print(4)
+    else:
+        if var_1 == 1:
+            print(2.666666666)
+        else:
+            if var_1 == 2:
+                print(3.46666666)
+            else:
+                if var_1 == 3:
+                    print(2.8952381)
+                else:
+                    var_2 = 0
+                    for var_3 in range(var_1+1) :
+                        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+                    print(4*var_2)

project-3/regex/code/code1022.py

@@ -0,0 +1,23 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 11
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        print(4)
+    else:
+        if i == 1:
+            print(2.666666666)
+        else:
+            if i == 2:
+                print(3.46666666)
+            else:
+                if i == 3:
+                    print(2.8952381)
+                else:
+                    pi = 0
+                    for j in range(i+1) :
+                        pi += (((-1)**j) / ((2*j)+1))
+                    print(4*pi)

project-3/regex/code/code1023.py

@@ -0,0 +1,22 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        print(4)
+    else:
+        if i == 1:
+            print(2.666666666)
+        else:
+            if i == 2:
+                print(3.46666666)
+            else:
+                if i == 3:
+                    print(2.8952381)
+                else:
+                    pi = 0
+                    for j in range(i+1) :
+                        pi += (((-1)**i) / ((2*i)+1))
+                    print(4*pi)

project-3/regex/code/code1024.py

@@ -0,0 +1,17 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    else:
+        if i == 1:
+            print(2.666666666)
+        else:
+            if i == 2:
+                print(3.46666666)
+            else:
+                if i == 3:
+                    print(2.8952381)
+                else:
+                    pi = 0
+                    for j in range(i+1) :
+                        pi += (((-1)**j) / ((2*j)+1))
+                    print(4*pi)

project-3/regex/code/code1025.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    print(sum)
+    return sum
+    print(sum)

project-3/regex/code/code1026.py

@@ -0,0 +1,12 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for var_2 in range (0,var_1+1):
+        sum+=((-1)**var_1)/((2*var_1)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1027.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1028.py

@@ -0,0 +1,12 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1029.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum
+    print(sum)
+    print(sum)

project-3/regex/code/code103.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    print(sum)
+    return sum

project-3/regex/code/code1030.py

@@ -0,0 +1,12 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    print(sum)
+    print(sum)

project-3/regex/code/code1031.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 11
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1032.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1033.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1034.py

@@ -0,0 +1,12 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if var_1 == 0:
+        return 4
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_1) / ((2*var_1)+1))
+        return(4*var_2)

project-3/regex/code/code1035.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1036.py

@@ -0,0 +1,12 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1037.py

@@ -0,0 +1,12 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        print(4*pi)

project-3/regex/code/code1038.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        print((4*pi))
+        return(4*pi)

project-3/regex/code/code1039.py

@@ -0,0 +1,12 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 9
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    ### VOTRE REPONSE
+    var_2 = 0
+    for var_3 in range(var_1+1):
+        var_2+=4*((-1)**var_3/(2*var_3+1))
+    print(var_2)

project-3/regex/code/code104.py

@@ -0,0 +1,6 @@
+def approx_pi(var_1):        
+    sum=0
+    for var_2 in range (0,var_1+1):
+        sum+=((-1)**var_1)/((2*var_1)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1040.py

@@ -0,0 +1,11 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    ### VOTRE REPONSE
+    var_2 = 0
+    for var_3 in range(var_1+1):
+        var_2+=4*((-1)**var_3/(2*var_3+1))
+    print(var_2)

project-3/regex/code/code1041.py

@@ -0,0 +1,11 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    ### VOTRE REPONSE
+    var_2 = 0
+    for var_3 in range(var_1+1):
+        var_2+=4*((-1)**var_3/(2*var_3+1))
+    print(var_2)

project-3/regex/code/code1042.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1):
+        var_2+=4*((-1)**var_3/(2*var_3+1))
+    print(var_2)

project-3/regex/code/code1043.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1044.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**x)/((2*x)+1)
+    sum=4*sum
+    print(sum)

project-3/regex/code/code1045.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 6
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**x)/((2*x)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1046.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 18
+    var_1 = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for var_2 in range (0,var_1+1):
+        sum+=((-1)**var_2)/((2*var_2)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1047.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**x)/((2*x)+1)
+    sum=4*sum
+    print(sum)
+    return sum

project-3/regex/code/code1048.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**x)/((2*x)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1049.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**x)/((2*x)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code105.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    i = 1
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1050.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1051.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    return(4*pi)

project-3/regex/code/code1052.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    return(4*pi)
+    print((4*pi))

project-3/regex/code/code1053.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    print((4*pi))
+    return(4*pi)

project-3/regex/code/code1054.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    print(4*pi)

project-3/regex/code/code1055.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if var_1 == 0:
+        return 4
+        print(4)
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_1) / ((2*var_1)+1))
+    return(4*var_2)

project-3/regex/code/code1056.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    return(4*pi)

project-3/regex/code/code1057.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 0
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    return(4*pi)

project-3/regex/code/code1058.py

@@ -0,0 +1,11 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 19
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print(4*var_2)

project-3/regex/code/code1059.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print(4*var_2)

project-3/regex/code/code106.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1060.py

@@ -0,0 +1,10 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print(4*var_2)

project-3/regex/code/code1061.py

@@ -0,0 +1,10 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print(4*var_2)

project-3/regex/code/code1062.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+        return pi

project-3/regex/code/code1063.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    print(pi)

project-3/regex/code/code1064.py

@@ -0,0 +1,8 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    var_3 = 0
+    if var_2 <= var_1 :
+        var_4 = ((-1)**var_2)/((2*var_2) +1)
+        var_3 += 4*var_4
+        var_2+=1
+    return var_3

project-3/regex/code/code1065.py

@@ -0,0 +1,9 @@
+def approx_pi(i):        
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    return pi
+    print(pi)

project-3/regex/code/code1066.py

@@ -0,0 +1,9 @@
+def approx_pi(i):        
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    print(pi)
+    return pi

project-3/regex/code/code1067.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    return pi

project-3/regex/code/code1068.py

@@ -0,0 +1,9 @@
+def approx_pi(i):        
+    i = 7
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    return pi

project-3/regex/code/code1069.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+        return(4*pi)

project-3/regex/code/code107.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 2
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        print(4)
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    return(4*pi)

project-3/regex/code/code1070.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 0
+    i = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+        return(4*pi)

project-3/regex/code/code1071.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        
+    i = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+        return(4*pi)

project-3/regex/code/code1072.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1073.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        print(4)
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+        return(4*pi)

project-3/regex/code/code1074.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if var_1 == 0:
+        return 4
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+        return(4*var_2)