From c5fcf7179a83ef65c86c6a4a390029149e518649 Mon Sep 17 00:00:00 2001 From: Franciszek Malinka Date: Tue, 5 Oct 2021 21:49:54 +0200 Subject: Duzy commit ze smieciami --- semestr-2/racket/cnf.rkt | 188 +++++ semestr-2/racket/cw.rkt | 57 ++ semestr-2/racket/deriv.rkt | 47 ++ semestr-2/racket/egzamin/rozw2.txt | 1 + semestr-2/racket/egzamin/zad1.bak | 1 + semestr-2/racket/egzamin/zad1.rkt | 300 ++++++++ semestr-2/racket/egzamin/zad1a.bak | 300 ++++++++ semestr-2/racket/egzamin/zad1a.rkt | 314 +++++++++ semestr-2/racket/egzamin/zad1b.bak | 314 +++++++++ semestr-2/racket/egzamin/zad1b.rkt | 482 +++++++++++++ semestr-2/racket/egzamin/zad2.bak | 119 ++++ semestr-2/racket/egzamin/zad2.rkt | 186 +++++ semestr-2/racket/egzamin/zad3.bak | 4 + semestr-2/racket/egzamin/zad3.rkt | 347 +++++++++ semestr-2/racket/egzamin/zad3a.bak | 298 ++++++++ semestr-2/racket/egzamin/zad3a.rkt | 301 ++++++++ semestr-2/racket/l10z18/solution.bak | 363 ++++++++++ semestr-2/racket/l10z18/solution.rkt | 409 +++++++++++ semestr-2/racket/l11/rozw.bak | 2 + semestr-2/racket/l11/rozw.rkt | 776 +++++++++++++++++++++ semestr-2/racket/l11/solution.bak | 18 + semestr-2/racket/l11/solution.rkt | 35 + .../compiled/drracket/errortrace/graph_rkt.dep | 1 + .../compiled/drracket/errortrace/graph_rkt.zo | Bin 0 -> 43422 bytes semestr-2/racket/l11z20/graph.bak | 97 +++ semestr-2/racket/l11z20/graph.rkt | 100 +++ semestr-2/racket/l11z20/solution.bak | 1 + semestr-2/racket/l11z20/solution.rkt | 245 +++++++ semestr-2/racket/l13/oceny.txt | 18 + semestr-2/racket/l13/rozw.rkt | 79 +++ semestr-2/racket/l13/solution.rkt | 124 ++++ semestr-2/racket/l13/zad6.rkt | 132 ++++ semestr-2/racket/l14z22/solution.bak | 70 ++ semestr-2/racket/l14z22/solution.rkt | 87 +++ semestr-2/racket/l15/kacp.bak | 55 ++ semestr-2/racket/l15/kacp.rkt | 59 ++ semestr-2/racket/l15/solution.bak | 7 + semestr-2/racket/l15/solution.rkt | 85 +++ semestr-2/racket/l7z12/solution.rkt | 95 +++ semestr-2/racket/l7z13/solution.rkt | 104 +++ semestr-2/racket/l8z14/solution.bak | 155 ++++ semestr-2/racket/l8z14/solution.rkt | 201 ++++++ semestr-2/racket/l8z15/solution.bak | 187 +++++ semestr-2/racket/l8z15/solution.rkt | 182 +++++ semestr-2/racket/l9/zad4.rkt | 202 ++++++ semestr-2/racket/l9/zad7.rkt | 340 +++++++++ semestr-2/racket/l9z16/solution.rkt | 42 ++ semestr-2/racket/l9z17/solution.rkt | 266 +++++++ semestr-2/racket/leftist.rkt | 105 +++ .../compiled/drracket/errortrace/prop_rkt.dep | 1 + .../compiled/drracket/errortrace/prop_rkt.zo | Bin 0 -> 1709 bytes .../compiled/drracket/errortrace/props_rkt.dep | 1 + .../compiled/drracket/errortrace/props_rkt.zo | Bin 0 -> 3273 bytes .../compiled/drracket/errortrace/solution_rkt.dep | 1 + .../compiled/drracket/errortrace/solution_rkt.zo | Bin 0 -> 10868 bytes .../compiled/drracket/errortrace/props_rkt.dep | 1 + .../compiled/drracket/errortrace/props_rkt.zo | Bin 0 -> 3273 bytes semestr-2/racket/lista5/julita/props.rkt | 52 ++ semestr-2/racket/lista5/julita/solution.bak | 164 +++++ semestr-2/racket/lista5/julita/solution.rkt | 164 +++++ semestr-2/racket/lista5/prop.rkt | 1 + semestr-2/racket/lista5/props.bak | 71 ++ semestr-2/racket/lista5/props.rkt | 52 ++ semestr-2/racket/lista5/skrr/solution.bak | 135 ++++ semestr-2/racket/lista5/skrr/solution.rkt | 88 +++ semestr-2/racket/lista5/sol2.rkt | 90 +++ semestr-2/racket/lista5/solution.bak | 135 ++++ semestr-2/racket/lista5/solution.rkt | 140 ++++ semestr-2/racket/lista5/xd.bak | 4 + semestr-2/racket/lista5/xd.rkt | 4 + semestr-2/racket/lista6/lista8/kappa.py | 13 + semestr-2/racket/lista6/lista8/zad1.bak | 98 +++ semestr-2/racket/lista6/lista8/zad1.rkt | 104 +++ semestr-2/racket/lista6/lista8/zad4.bak | 114 +++ semestr-2/racket/lista6/lista8/zad4.rkt | 118 ++++ semestr-2/racket/lista6/lista8/zad5.bak | 1 + semestr-2/racket/lista6/lista8/zad5.rkt | 151 ++++ semestr-2/racket/lista6/lista8/zad6.bak | 151 ++++ semestr-2/racket/lista6/lista8/zad6.rkt | 171 +++++ semestr-2/racket/lista6/lista8/zadanie.rkt | 98 +++ semestr-2/racket/lista6/solution.bak | 27 + semestr-2/racket/lista6/solution.rkt | 73 ++ semestr-2/racket/lista6/zad11/solution.bak | 36 + semestr-2/racket/lista6/zad11/solution.rkt | 58 ++ semestr-2/racket/luk.rkt | 137 ++++ semestr-2/racket/rac.rkt | 371 ++++++++++ semestr-2/racket/solution.rkt | 14 + 87 files changed, 10740 insertions(+) create mode 100644 semestr-2/racket/cnf.rkt create mode 100644 semestr-2/racket/cw.rkt create mode 100644 semestr-2/racket/deriv.rkt create mode 100644 semestr-2/racket/egzamin/rozw2.txt create mode 100644 semestr-2/racket/egzamin/zad1.bak create mode 100644 semestr-2/racket/egzamin/zad1.rkt create mode 100644 semestr-2/racket/egzamin/zad1a.bak create mode 100644 semestr-2/racket/egzamin/zad1a.rkt create mode 100644 semestr-2/racket/egzamin/zad1b.bak create mode 100644 semestr-2/racket/egzamin/zad1b.rkt create mode 100644 semestr-2/racket/egzamin/zad2.bak create mode 100644 semestr-2/racket/egzamin/zad2.rkt create mode 100644 semestr-2/racket/egzamin/zad3.bak create mode 100644 semestr-2/racket/egzamin/zad3.rkt create mode 100644 semestr-2/racket/egzamin/zad3a.bak create mode 100644 semestr-2/racket/egzamin/zad3a.rkt create mode 100644 semestr-2/racket/l10z18/solution.bak create mode 100644 semestr-2/racket/l10z18/solution.rkt create mode 100644 semestr-2/racket/l11/rozw.bak create mode 100644 semestr-2/racket/l11/rozw.rkt create mode 100644 semestr-2/racket/l11/solution.bak create mode 100644 semestr-2/racket/l11/solution.rkt create mode 100644 semestr-2/racket/l11z20/compiled/drracket/errortrace/graph_rkt.dep create mode 100644 semestr-2/racket/l11z20/compiled/drracket/errortrace/graph_rkt.zo create mode 100644 semestr-2/racket/l11z20/graph.bak create mode 100644 semestr-2/racket/l11z20/graph.rkt create mode 100644 semestr-2/racket/l11z20/solution.bak create mode 100644 semestr-2/racket/l11z20/solution.rkt create mode 100644 semestr-2/racket/l13/oceny.txt create mode 100644 semestr-2/racket/l13/rozw.rkt create mode 100644 semestr-2/racket/l13/solution.rkt create mode 100644 semestr-2/racket/l13/zad6.rkt create mode 100644 semestr-2/racket/l14z22/solution.bak create mode 100644 semestr-2/racket/l14z22/solution.rkt create mode 100644 semestr-2/racket/l15/kacp.bak create mode 100644 semestr-2/racket/l15/kacp.rkt create mode 100644 semestr-2/racket/l15/solution.bak create mode 100644 semestr-2/racket/l15/solution.rkt create mode 100644 semestr-2/racket/l7z12/solution.rkt create mode 100644 semestr-2/racket/l7z13/solution.rkt create mode 100644 semestr-2/racket/l8z14/solution.bak create mode 100644 semestr-2/racket/l8z14/solution.rkt create mode 100644 semestr-2/racket/l8z15/solution.bak create mode 100644 semestr-2/racket/l8z15/solution.rkt create mode 100644 semestr-2/racket/l9/zad4.rkt create mode 100644 semestr-2/racket/l9/zad7.rkt create mode 100644 semestr-2/racket/l9z16/solution.rkt create mode 100644 semestr-2/racket/l9z17/solution.rkt create mode 100644 semestr-2/racket/leftist.rkt create mode 100644 semestr-2/racket/lista5/compiled/drracket/errortrace/prop_rkt.dep create mode 100644 semestr-2/racket/lista5/compiled/drracket/errortrace/prop_rkt.zo create mode 100644 semestr-2/racket/lista5/compiled/drracket/errortrace/props_rkt.dep create mode 100644 semestr-2/racket/lista5/compiled/drracket/errortrace/props_rkt.zo create mode 100644 semestr-2/racket/lista5/compiled/drracket/errortrace/solution_rkt.dep create mode 100644 semestr-2/racket/lista5/compiled/drracket/errortrace/solution_rkt.zo create mode 100644 semestr-2/racket/lista5/julita/compiled/drracket/errortrace/props_rkt.dep create mode 100644 semestr-2/racket/lista5/julita/compiled/drracket/errortrace/props_rkt.zo create mode 100644 semestr-2/racket/lista5/julita/props.rkt create mode 100644 semestr-2/racket/lista5/julita/solution.bak create mode 100644 semestr-2/racket/lista5/julita/solution.rkt create mode 100644 semestr-2/racket/lista5/prop.rkt create mode 100644 semestr-2/racket/lista5/props.bak create mode 100644 semestr-2/racket/lista5/props.rkt create mode 100644 semestr-2/racket/lista5/skrr/solution.bak create mode 100644 semestr-2/racket/lista5/skrr/solution.rkt create mode 100644 semestr-2/racket/lista5/sol2.rkt create mode 100644 semestr-2/racket/lista5/solution.bak create mode 100644 semestr-2/racket/lista5/solution.rkt create mode 100644 semestr-2/racket/lista5/xd.bak create mode 100644 semestr-2/racket/lista5/xd.rkt create mode 100644 semestr-2/racket/lista6/lista8/kappa.py create mode 100644 semestr-2/racket/lista6/lista8/zad1.bak create mode 100644 semestr-2/racket/lista6/lista8/zad1.rkt create mode 100644 semestr-2/racket/lista6/lista8/zad4.bak create mode 100644 semestr-2/racket/lista6/lista8/zad4.rkt create mode 100644 semestr-2/racket/lista6/lista8/zad5.bak create mode 100644 semestr-2/racket/lista6/lista8/zad5.rkt create mode 100644 semestr-2/racket/lista6/lista8/zad6.bak create mode 100644 semestr-2/racket/lista6/lista8/zad6.rkt create mode 100644 semestr-2/racket/lista6/lista8/zadanie.rkt create mode 100644 semestr-2/racket/lista6/solution.bak create mode 100644 semestr-2/racket/lista6/solution.rkt create mode 100644 semestr-2/racket/lista6/zad11/solution.bak create mode 100644 semestr-2/racket/lista6/zad11/solution.rkt create mode 100644 semestr-2/racket/luk.rkt create mode 100644 semestr-2/racket/rac.rkt create mode 100644 semestr-2/racket/solution.rkt (limited to 'semestr-2/racket') diff --git a/semestr-2/racket/cnf.rkt b/semestr-2/racket/cnf.rkt new file mode 100644 index 0000000..67bd70f --- /dev/null +++ b/semestr-2/racket/cnf.rkt @@ -0,0 +1,188 @@ +#lang racket + +(define (var? t) (symbol? t)) + +(define (neg? t) + (and (list? t) + (= 2 (length t)) + (eq? 'neg (car t)))) + +(define (conj? t) + (and (list? t) + (= 3 (length t)) + (eq? 'conj (car t)))) + +(define (disj? t) + (and (list? t) + (= 3 (length t)) + (eq? 'disj (car t)))) + +(define (lit? t) + (or (var? t) + (and (neg? t) + (var? (neg-subf t))))) + +(define (prop? f) + (or (var? f) + (and (neg? f) + (prop? (neg-subf f))) + (and (disj? f) + (prop? (disj-left f)) + (prop? (disj-right f))) + (and (conj? f) + (prop? (conj-left f)) + (prop? (conj-right f))))) + +(define (make-conj left right) + (list 'conj left right)) + +(define (make-disj left right) + (list 'disj left right)) + +(define (make-neg f) + (list 'neg f)) + +(define (conj-left f) + (if (conj? f) + (cadr f) + (error "Złe dane ze znacznikiem -- CONJ-LEFT" f))) + +(define (conj-right f) + (if (conj? f) + (caddr f) + (error "Złe dane ze znacznikiem -- CONJ-RIGHT" f))) + +(define (disj-left f) + (if (disj? f) + (cadr f) + (error "Złe dane ze znacznikiem -- DISJ-LEFT" f))) + +(define (disj-right f) + (if (disj? f) + (caddr f) + (error "Złe dane ze znacznikiem -- DISJ-RIGHT" f))) + +(define (neg-subf f) + (if (neg? f) + (cadr f) + (error "Złe dane ze znacznikiem -- NEG-FORM" f))) + +(define (lit-var f) + (cond [(var? f) f] + [(neg? f) (neg-subf f)] + [else (error "Złe dane ze znacznikiem -- LIT-VAR" f)])) + +(define (free-vars f) + (cond [(null? f) null] + [(var? f) (list f)] + [(neg? f) (free-vars (neg-subf f))] + [(conj? f) (append (free-vars (conj-left f)) + (free-vars (conj-right f)))] + [(disj? f) (append (free-vars (disj-left f)) + (free-vars (disj-right f)))] + [else (error "Zła formula -- FREE-VARS" f)])) + +(define (gen-vals xs) + (if (null? xs) + (list null) + (let* + ((vss (gen-vals (cdr xs))) + (x (car xs)) + (vst (map (λ (vs) (cons (list x true) vs)) vss)) + (vsf (map (λ (vs) (cons (list x false) vs)) vss))) + (append vst vsf)))) + +(define (eval-formula f evaluation) + (cond [(var? f) + (let ((val (assoc f evaluation))) + (if (not val) + (error "Zmienna wolna nie wystepuje w wartościowaniu -- EVAL-FORMULA" f evaluation) + (cadr val)))] + [(neg? f) (not (eval-formula (neg-subf f) evaluation))] + [(disj? f) (or (eval-formula (disj-left f) evaluation) + (eval-formula (disj-right f) evaluation))] + [(conj? f) (and (eval-formula (conj-left f) evaluation) + (eval-formula (conj-right f) evaluation))] + [else (error "Zła formuła -- EVAL-FORMULA" f evaluation)])) + +(define (falsifable-eval? f) + (let* ((evaluations (gen-vals (free-vars f))) + (results (map (λ (evaluation) (eval-formula f evaluation)) evaluations))) + (ormap false? results))) + +(define (nff? f) + (cond [(lit? f) true] + [(neg? f) false] + [(conj? f) (and (nff? (conj-left f)) + (nff? (conj-right f)))] + [(disj? f) (and (nff? (disj-left f)) + (nff? (disj-right f)))] + [else (error "Zła formuła -- NFF?" f)])) + +(define (convert-to-nnf f) + (cond [(lit? f) f] + [(neg? f) (convert-negation (neg-subf f))] + [(conj? f) (make-conj (convert-to-nnf (conj-left f)) + (convert-to-nnf (conj-right f)))] + [(disj? f) (make-disj (convert-to-nnf (disj-left f)) + (convert-to-nnf (disj-right f)))] + [else (error "Zła formuła -- CONVERT" f)])) + +(define (convert-negation f) + (cond [(lit? f) + (if (var? f) + (make-neg f) + (neg-subf f))] + [(neg? f) (convert-to-nnf (neg-subf f))] + [(conj? f) (make-disj (convert-negation (conj-left f)) + (convert-negation (conj-right f)))] + [(disj? f) (make-conj (convert-negation (disj-left f)) + (convert-negation (disj-right f)))] + [else (error "Zła formuła -- CONVERT-NEGATION" f)])) + +(define (clause? x) + (and (list? x) + (andmap lit? x))) + +(define (clause-empty? x) + (and (clause? x) + (null? x))) + +(define (cnf? x) + (and (list? x) + (andmap clause? x))) + +(define (flatmap proc seq) + (foldl append null (map proc seq))) + +(define (convert-to-cnf f) + (define (convert f) + (cond [(lit? f) (list (list f))] + [(conj? f) (append (convert-to-cnf (conj-left f)) + (convert-to-cnf (conj-right f)))] + [(disj? f) + (let ((clause-left (convert-to-cnf (disj-left f))) + (clause-right (convert-to-cnf (disj-right f)))) + (flatmap (λ (clause) + (map (λ (clause2) + (append clause2 clause)) clause-left)) + clause-right))])) + (convert (convert-to-nnf f))) + +(define (falsifable-clause? clause) + (cond [(clause-empty? clause) true] + [(lit? (findf (λ (l) (equal? + l + (convert-to-nnf (make-neg (car clause))))) + clause)) false] + [else (falsifable-clause? (cdr clause))])) + +(define (falsifable-cnf? f) + (define (neg-value lit) + (if (var? lit) + (list lit false) + (list (neg-subf lit) true))) + (ormap (λ (clause) (if (falsifable-clause? clause) + (map neg-value clause) + false)) + (convert-to-cnf f))) \ No newline at end of file diff --git a/semestr-2/racket/cw.rkt b/semestr-2/racket/cw.rkt new file mode 100644 index 0000000..f1e706f --- /dev/null +++ b/semestr-2/racket/cw.rkt @@ -0,0 +1,57 @@ +#lang racket + +(define (accumulate op initial sequence) + (if (null? sequence) + initial + (op (car sequence) + (accumulate op initial (cdr sequence))))) + +(define (horner-eval x coefficient-sequence) + (accumulate (lambda (this-coeff higher-terms) + (+ this-coeff (* x higher-terms))) + 0 + coefficient-sequence)) + + +(define (accumulate-n op init seqs) + (if (null? (car seqs)) + null + (cons (accumulate op init (map car seqs)) + (accumulate-n op init (map cdr seqs))))) + +(define (count-leaves t) + (accumulate + 0 (map (lambda (x) + (if (not (pair? x)) + 1 + (count-leaves x))) t))) + +(define (flatmap proc seq) + (accumulate append null (map proc seq))) + +(define (prime? x) (= (modulo x 2) 1)) + +(define (prime-sum? pair) + (prime? (+ (car pair) (cadr pair)))) + +(define (make-pair-sum pair) + (list (car pair) (cadr pair) (+ (car pair) (cadr pair)))) + +(define (enumerate-interval low high) + (if (> low high) + null + (cons low (enumerate-interval (+ 1 low) high)))) + +(define (unique-pairs n) + (flatmap (lambda (i) + (map (lambda (j) (list j i)) + (enumerate-interval 1 (- i 1)))) + (enumerate-interval 1 n))) + +(define (prime-sum-pairs n) + (map make-pair-sum + (filter prime-sum? (unique-pairs n)))) + +(define (is-eq-s? s triplet) + (= s (accumulate + 0 triplet))) + +(define \ No newline at end of file diff --git a/semestr-2/racket/deriv.rkt b/semestr-2/racket/deriv.rkt new file mode 100644 index 0000000..0eef9d2 --- /dev/null +++ b/semestr-2/racket/deriv.rkt @@ -0,0 +1,47 @@ +#lang racket + +(define (variable? x) (symbol? x)) + +(define (same-variable? v1 v2) + (and (variable? v1) (variable? v2) (eq? v1 v2))) + +(define (=number? exp num) + (and (number? exp) (= exp num))) + +(define (make-sum a1 a2) + (cond ((=number? a1 0) a2) + ((=number? a2 0) a1) + ((and (number? a1) (number? a2) (+ a1 a2))) + (else (list '+ a1 a2)))) +(define (sum? x) + (and (pair? x) (eq? (car x) '+))) +(define (addend s) (cadr s)) +(define (augend s) (caddr s)) + +(define (make-product m1 m2) + (cond ((or (=number? m1 0) (=number? m2 0)) 0) + ((=number? m1 1) m2) + ((=number? m2 1) m1) + ((and (number? m1) (number? m2)) (* m1 m2)) + (else (list '* m1 m2)))) +(define (product? x) + (and (pair? x) (eq? (car x) '*))) +(define (multiplier p) (cadr p)) +(define (multiplicand p) (caddr p)) + +(define (deriv exp var) + (cond ((number? exp) 0) + ((variable? exp) + (if (same-variable? exp var) 1 0)) + ((sum? exp) + (make-sum (deriv (addend exp) var) + (deriv (augend exp) var))) + ((product? exp) + (make-sum + (make-product (multiplier exp) + (deriv (multiplicand exp) var)) + (make-product (deriv (multiplier exp) var) + (multiplicand exp)))) + (else + (error "Nieznany rodzaj wyrazenia -- DERIV" exp)))) + \ No newline at end of file diff --git a/semestr-2/racket/egzamin/rozw2.txt b/semestr-2/racket/egzamin/rozw2.txt new file mode 100644 index 0000000..a70232e --- /dev/null +++ b/semestr-2/racket/egzamin/rozw2.txt @@ -0,0 +1 @@ +Zasada indukcji dla \ No newline at end of file diff --git a/semestr-2/racket/egzamin/zad1.bak b/semestr-2/racket/egzamin/zad1.bak new file mode 100644 index 0000000..6f1f7b4 --- /dev/null +++ b/semestr-2/racket/egzamin/zad1.bak @@ -0,0 +1 @@ +#lang racket diff --git a/semestr-2/racket/egzamin/zad1.rkt b/semestr-2/racket/egzamin/zad1.rkt new file mode 100644 index 0000000..a90d2fd --- /dev/null +++ b/semestr-2/racket/egzamin/zad1.rkt @@ -0,0 +1,300 @@ +#lang racket + +;; ZADANIE 1 +;; ========= + +;; W tym zadaniu rozważamy język WHILE (w formie z grubsza +;; odpowiadającej tej z wykładu), z blokami deklarującymi zmienne o +;; lokalnym zakresie. + +;; Zadanie polega na dodaniu do języka procedur definiowanych na +;; zewnątrz głównego polecenia programu (podobnie jak w C, gdzie +;; główne polecenie odpowiadałoby procedurze main, czy Pascalu) — o +;; dowolnym wybranym przez siebie modelu działania. W tym celu należy: +;; · rozszerzyć składnię abstrakcyjną o składnię procedur i rozbudować odpowiednio składnię programów +;; · rozszerzyć procedurę parsowania +;; · rozszerzyć ewaluator +;; · *opisać* wybrany model działania procedur, w tym jego potencjalne zalety lub ograniczenia +;; Należy rozszerzyć poniższy szablon, a część słowną zadania umieścić +;; w komentarzu, podobnie jak niniejsze polecenie. + +;; Uwaga! Zadanie jest *bardzo* szeroko sformułowane, jest wiele +;; sensownych rozwiązań które stosowały liczne języki imperatywne w +;; historii — nie jest treścią zadania znalezienie *najlepszego*, +;; tylko swojego, które *rozumiecie*. Wybrany model działania procedur +;; *może* być relatywnie ubogi, jednak jeśli tak się zrobi, warto +;; pokazać że ma się tego świadomość w słownym opisie jego działania. + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (name) #:transparent) +(struct call-expr (name args) #:transparent) +(struct return-expr (val) #:transparent) + +(define (operator? x) + (member x '(+ * - / > < = >= <=))) + +(define (keyword? x) + (member x '(skip while if := func call return))) + +(define (expr? e) + (match e + [(const v) + (integer? v)] + [(var-expr x) + (and (symbol? x) + (not (keyword? x)))] + [(binop op l r) + (and (operator? op) + (expr? l) + (expr? r))] + [_ false])) + +(struct skip () #:transparent) +(struct assign (id exp) #:transparent) +(struct if-cmd (exp ct cf) #:transparent) +(struct while (exp cmd) #:transparent) +(struct comp (left right) #:transparent) +(struct var-in (name expr cmd) #:transparent) +(struct function (name args cmd) #:transparent) + +(define (cmd? c) + (match c + [(skip) true] + [(assign x e) (and (symbol? x) (expr? e))] + [(if-cmd e ct cf) (and (expr? e) (cmd? ct) (cmd? cf))] + [(while e c) (and (expr? e) (cmd? c))] + [(comp c1 c2) (and (cmd? c1) (cmd? c2))] + [(var-in x e c) (and (symbol? x) (expr? e) (cmd? c))] + [(function f a c) (and (symbol? f) (list? a) (andmap symbol? a) (cmd? c))])) + +(define (prog? p) + (cmd? p)) + +(define (parse-expr p) + (cond + [(number? p) (const p)] + [(and (symbol? p) + (not (keyword? p))) + (var-expr p)] + [(and (list? p) + (= 3 (length p)) + (operator? (car p))) + (binop (first p) + (parse-expr (second p)) + (parse-expr (third p)))] + [(and (list? p) ; <------ wywołanie funkcji + (= (length p) 3) + (eq? (first p) 'call) + (symbol? (second p)) + (list? (third p))) + (call-expr (second p) (map parse-expr (third p)))] + [else false])) + +(define (parse-cmd q) + (cond + [(eq? q 'skip) (skip)] + [(and (list? q) + (= (length q) 3) + (eq? (second q) ':=)) + (assign (first q) (parse-expr (third q)))] + [(and (list? q) + (= (length q) 4) + (eq? (first q) 'if)) + (if-cmd (parse-expr (second q)) (parse-cmd (third q)) (parse-cmd (fourth q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'while)) + (while (parse-expr (second q)) (parse-cmd (third q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'var) + (list? (second q)) + (= (length (second q)) 2)) + (var-in (first (second q)) + (parse-expr (second (second q))) + (parse-cmd (third q)))] + [(and (list? q) ; <------ funkcje + (= (length q) 4) + (eq? (first q) 'func) + (symbol? (second q)) + (list? (third q)) + (andmap symbol? (third q))) + (function (second q) (third q) (parse-cmd (fourth q)))] + [(and (list? q) + (= (length q) 2) + (eq? (first q) 'return)) + (return-expr (parse-expr (second q)))] + [(and (list? q) + (>= (length q) 2)) + (desugar-comp (map parse-cmd q))] + [else false])) + +(define (desugar-comp cs) + (if (null? (cdr cs)) + (car cs) + (comp (car cs) + (desugar-comp (cdr cs))))) + +(define (value? v) + (number? v)) + +(struct mem (xs) #:transparent) + +(define (mem-lookup x m) + (define (assoc-lookup xs) + (cond + [(null? xs) (error "Undefined variable" x)] + [(eq? x (caar xs)) (cdar xs)] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (mem-xs m))) + +(define (mem-defined? x m) ; <----------- !!! Sprawdz, czy x jest w ogole zdefiniowane + (define (assoc-lookup xs) + (cond + [(null? xs) #f] + [(eq? x (caar xs) #t)] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (mem-xs m))) + +(define (mem-update x v m) + (define (assoc-update xs) + (cond + [(null? xs) (error "Undefined variable" x)] + [(eq? x (caar xs)) (cons (cons x v) (cdr xs))] + [else (cons (car xs) (assoc-update (cdr xs)))])) + (mem (assoc-update (mem-xs m)))) + +(define (mem-alloc x v m) + (mem (cons (cons x v) (mem-xs m)))) + +(define (mem-drop-last m) + (cond + [(null? (mem-xs m)) + (error "Deallocating from empty memory")] + [else + (mem (cdr (mem-xs m)))])) + +(define empty-mem + (mem null)) + +(define (op->proc op) + (match op + ['+ +] + ['- -] + ['* *] + ['/ /] + ['< (lambda (x y) (if (< x y) 1 0))] + ['> (lambda (x y) (if (> x y) 1 0))] + ['= (lambda (x y) (if (= x y) 1 0))] + ['<= (lambda (x y) (if (<= x y) 1 0))] + ['>= (lambda (x y) (if (>= x y) 1 0))] + )) + +;; zał: (expr? e) i (mem? m) jest prawdą +;; (value? (eval e m)) jest prawdą +(define (eval e m) + (match e + [(const v) v] + [(var-expr x) (mem-lookup x m)] + [(binop op l r) + (let ((vl (eval l m)) + (vr (eval r m)) + (p (op->proc op))) + (p vl vr))] + [(call-expr name args) + (match (mem-lookup name m) + [(clo func-args cmd) + (if (= (length args) (length func-args)) + (let* ([func-mem (assign-values args func-args m)] + [final-mem (eval-cmd cmd func-mem)] + [ret (mem-lookup 'RETURN final-mem)]) + (if ret + ret + (error "No return statement in function" name))) + (error "Arity mismatch, function" name "takes" (length func-args) ", got" (length args)))] + [else (error "Undefined function" name)])])) + +(define (assign-values args func-args mem) + (if (null? args) + mem + (assign-values (cdr args) (cdr func-args) (mem-alloc (car func-args) (eval (car args) mem) mem)))) + + +(struct clo (args cmd)) + +;; zał: (cmd? c) (mem? m) +;; (mem? (eval-cmd c m)) +(define (eval-cmd c m) + (if (mem-lookup 'RETURN m) + m + (match c + [(skip) m] + [(assign x e) (mem-update x (eval e m) m)] + [(if-cmd e ct cf) (if (= (eval e m) 0) + (eval-cmd cf m) + (eval-cmd ct m))] + [(while e cw) (if (= (eval e m) 0) + m + (let* ((m1 (eval-cmd cw m)) + (m2 (eval-cmd c m1))) + m2))] + [(comp c1 c2) (let* ((m1 (eval-cmd c1 m)) + (m2 (eval-cmd c2 m1))) + m2)] + [(var-in x e c) (let* ((v (eval e m)) + (m1 (mem-alloc x v m)) + (m2 (eval-cmd c m1))) + (mem-drop-last m2))] + [(function name args cmd) + (mem-alloc name (clo args cmd) m)] + [(return-expr val) + (mem-update 'RETURN (eval val m) m)] + [_ (error "Unknown command" c "— likely a syntax error")]))) + + +(define (eval-prog p m) + (let ((final-mem (eval-cmd p (mem-alloc 'RETURN #f m)))) + (with-handlers ([exn:fail? (lambda (v) (error "Undefined reference to main"))]) + (match (mem-lookup 'main final-mem) + [(clo args cmd) (mem-lookup 'RETURN (eval-cmd cmd final-mem))])))) + +(define WHILE_FACT + '({func decr (x) + {(x := (- x 1)) + (return x)}} + {func main () + {(i := 1) + (while (> t 0) + {(i := (* i t)) + (t := (call decr (t)))}) + (return i)}} + )) + +(define TEST + '({func decr (x) (return (- x 1))} + {func main () + (var (x 1) + {(x := (+ x 1)) + (return (call decr (x)))})})) + +(define TEST2 + '({func decr (x) (return (- x 1))} + {func main () (return (call decr (3)))})) + +(define TEST3 + '({func sth (x) + {(i := -1) + (return x)}} + {func main () + {(i := 2) + (return (call sth (i)))}})) + +(define TEST4 + '(func f () + {return 1})) + +(define (fact n) + (let* ([init-env (mem-alloc 'i 1 (mem-alloc 't n empty-mem))]) + (eval-prog (parse-cmd WHILE_FACT) init-env))) + diff --git a/semestr-2/racket/egzamin/zad1a.bak b/semestr-2/racket/egzamin/zad1a.bak new file mode 100644 index 0000000..a90d2fd --- /dev/null +++ b/semestr-2/racket/egzamin/zad1a.bak @@ -0,0 +1,300 @@ +#lang racket + +;; ZADANIE 1 +;; ========= + +;; W tym zadaniu rozważamy język WHILE (w formie z grubsza +;; odpowiadającej tej z wykładu), z blokami deklarującymi zmienne o +;; lokalnym zakresie. + +;; Zadanie polega na dodaniu do języka procedur definiowanych na +;; zewnątrz głównego polecenia programu (podobnie jak w C, gdzie +;; główne polecenie odpowiadałoby procedurze main, czy Pascalu) — o +;; dowolnym wybranym przez siebie modelu działania. W tym celu należy: +;; · rozszerzyć składnię abstrakcyjną o składnię procedur i rozbudować odpowiednio składnię programów +;; · rozszerzyć procedurę parsowania +;; · rozszerzyć ewaluator +;; · *opisać* wybrany model działania procedur, w tym jego potencjalne zalety lub ograniczenia +;; Należy rozszerzyć poniższy szablon, a część słowną zadania umieścić +;; w komentarzu, podobnie jak niniejsze polecenie. + +;; Uwaga! Zadanie jest *bardzo* szeroko sformułowane, jest wiele +;; sensownych rozwiązań które stosowały liczne języki imperatywne w +;; historii — nie jest treścią zadania znalezienie *najlepszego*, +;; tylko swojego, które *rozumiecie*. Wybrany model działania procedur +;; *może* być relatywnie ubogi, jednak jeśli tak się zrobi, warto +;; pokazać że ma się tego świadomość w słownym opisie jego działania. + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (name) #:transparent) +(struct call-expr (name args) #:transparent) +(struct return-expr (val) #:transparent) + +(define (operator? x) + (member x '(+ * - / > < = >= <=))) + +(define (keyword? x) + (member x '(skip while if := func call return))) + +(define (expr? e) + (match e + [(const v) + (integer? v)] + [(var-expr x) + (and (symbol? x) + (not (keyword? x)))] + [(binop op l r) + (and (operator? op) + (expr? l) + (expr? r))] + [_ false])) + +(struct skip () #:transparent) +(struct assign (id exp) #:transparent) +(struct if-cmd (exp ct cf) #:transparent) +(struct while (exp cmd) #:transparent) +(struct comp (left right) #:transparent) +(struct var-in (name expr cmd) #:transparent) +(struct function (name args cmd) #:transparent) + +(define (cmd? c) + (match c + [(skip) true] + [(assign x e) (and (symbol? x) (expr? e))] + [(if-cmd e ct cf) (and (expr? e) (cmd? ct) (cmd? cf))] + [(while e c) (and (expr? e) (cmd? c))] + [(comp c1 c2) (and (cmd? c1) (cmd? c2))] + [(var-in x e c) (and (symbol? x) (expr? e) (cmd? c))] + [(function f a c) (and (symbol? f) (list? a) (andmap symbol? a) (cmd? c))])) + +(define (prog? p) + (cmd? p)) + +(define (parse-expr p) + (cond + [(number? p) (const p)] + [(and (symbol? p) + (not (keyword? p))) + (var-expr p)] + [(and (list? p) + (= 3 (length p)) + (operator? (car p))) + (binop (first p) + (parse-expr (second p)) + (parse-expr (third p)))] + [(and (list? p) ; <------ wywołanie funkcji + (= (length p) 3) + (eq? (first p) 'call) + (symbol? (second p)) + (list? (third p))) + (call-expr (second p) (map parse-expr (third p)))] + [else false])) + +(define (parse-cmd q) + (cond + [(eq? q 'skip) (skip)] + [(and (list? q) + (= (length q) 3) + (eq? (second q) ':=)) + (assign (first q) (parse-expr (third q)))] + [(and (list? q) + (= (length q) 4) + (eq? (first q) 'if)) + (if-cmd (parse-expr (second q)) (parse-cmd (third q)) (parse-cmd (fourth q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'while)) + (while (parse-expr (second q)) (parse-cmd (third q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'var) + (list? (second q)) + (= (length (second q)) 2)) + (var-in (first (second q)) + (parse-expr (second (second q))) + (parse-cmd (third q)))] + [(and (list? q) ; <------ funkcje + (= (length q) 4) + (eq? (first q) 'func) + (symbol? (second q)) + (list? (third q)) + (andmap symbol? (third q))) + (function (second q) (third q) (parse-cmd (fourth q)))] + [(and (list? q) + (= (length q) 2) + (eq? (first q) 'return)) + (return-expr (parse-expr (second q)))] + [(and (list? q) + (>= (length q) 2)) + (desugar-comp (map parse-cmd q))] + [else false])) + +(define (desugar-comp cs) + (if (null? (cdr cs)) + (car cs) + (comp (car cs) + (desugar-comp (cdr cs))))) + +(define (value? v) + (number? v)) + +(struct mem (xs) #:transparent) + +(define (mem-lookup x m) + (define (assoc-lookup xs) + (cond + [(null? xs) (error "Undefined variable" x)] + [(eq? x (caar xs)) (cdar xs)] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (mem-xs m))) + +(define (mem-defined? x m) ; <----------- !!! Sprawdz, czy x jest w ogole zdefiniowane + (define (assoc-lookup xs) + (cond + [(null? xs) #f] + [(eq? x (caar xs) #t)] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (mem-xs m))) + +(define (mem-update x v m) + (define (assoc-update xs) + (cond + [(null? xs) (error "Undefined variable" x)] + [(eq? x (caar xs)) (cons (cons x v) (cdr xs))] + [else (cons (car xs) (assoc-update (cdr xs)))])) + (mem (assoc-update (mem-xs m)))) + +(define (mem-alloc x v m) + (mem (cons (cons x v) (mem-xs m)))) + +(define (mem-drop-last m) + (cond + [(null? (mem-xs m)) + (error "Deallocating from empty memory")] + [else + (mem (cdr (mem-xs m)))])) + +(define empty-mem + (mem null)) + +(define (op->proc op) + (match op + ['+ +] + ['- -] + ['* *] + ['/ /] + ['< (lambda (x y) (if (< x y) 1 0))] + ['> (lambda (x y) (if (> x y) 1 0))] + ['= (lambda (x y) (if (= x y) 1 0))] + ['<= (lambda (x y) (if (<= x y) 1 0))] + ['>= (lambda (x y) (if (>= x y) 1 0))] + )) + +;; zał: (expr? e) i (mem? m) jest prawdą +;; (value? (eval e m)) jest prawdą +(define (eval e m) + (match e + [(const v) v] + [(var-expr x) (mem-lookup x m)] + [(binop op l r) + (let ((vl (eval l m)) + (vr (eval r m)) + (p (op->proc op))) + (p vl vr))] + [(call-expr name args) + (match (mem-lookup name m) + [(clo func-args cmd) + (if (= (length args) (length func-args)) + (let* ([func-mem (assign-values args func-args m)] + [final-mem (eval-cmd cmd func-mem)] + [ret (mem-lookup 'RETURN final-mem)]) + (if ret + ret + (error "No return statement in function" name))) + (error "Arity mismatch, function" name "takes" (length func-args) ", got" (length args)))] + [else (error "Undefined function" name)])])) + +(define (assign-values args func-args mem) + (if (null? args) + mem + (assign-values (cdr args) (cdr func-args) (mem-alloc (car func-args) (eval (car args) mem) mem)))) + + +(struct clo (args cmd)) + +;; zał: (cmd? c) (mem? m) +;; (mem? (eval-cmd c m)) +(define (eval-cmd c m) + (if (mem-lookup 'RETURN m) + m + (match c + [(skip) m] + [(assign x e) (mem-update x (eval e m) m)] + [(if-cmd e ct cf) (if (= (eval e m) 0) + (eval-cmd cf m) + (eval-cmd ct m))] + [(while e cw) (if (= (eval e m) 0) + m + (let* ((m1 (eval-cmd cw m)) + (m2 (eval-cmd c m1))) + m2))] + [(comp c1 c2) (let* ((m1 (eval-cmd c1 m)) + (m2 (eval-cmd c2 m1))) + m2)] + [(var-in x e c) (let* ((v (eval e m)) + (m1 (mem-alloc x v m)) + (m2 (eval-cmd c m1))) + (mem-drop-last m2))] + [(function name args cmd) + (mem-alloc name (clo args cmd) m)] + [(return-expr val) + (mem-update 'RETURN (eval val m) m)] + [_ (error "Unknown command" c "— likely a syntax error")]))) + + +(define (eval-prog p m) + (let ((final-mem (eval-cmd p (mem-alloc 'RETURN #f m)))) + (with-handlers ([exn:fail? (lambda (v) (error "Undefined reference to main"))]) + (match (mem-lookup 'main final-mem) + [(clo args cmd) (mem-lookup 'RETURN (eval-cmd cmd final-mem))])))) + +(define WHILE_FACT + '({func decr (x) + {(x := (- x 1)) + (return x)}} + {func main () + {(i := 1) + (while (> t 0) + {(i := (* i t)) + (t := (call decr (t)))}) + (return i)}} + )) + +(define TEST + '({func decr (x) (return (- x 1))} + {func main () + (var (x 1) + {(x := (+ x 1)) + (return (call decr (x)))})})) + +(define TEST2 + '({func decr (x) (return (- x 1))} + {func main () (return (call decr (3)))})) + +(define TEST3 + '({func sth (x) + {(i := -1) + (return x)}} + {func main () + {(i := 2) + (return (call sth (i)))}})) + +(define TEST4 + '(func f () + {return 1})) + +(define (fact n) + (let* ([init-env (mem-alloc 'i 1 (mem-alloc 't n empty-mem))]) + (eval-prog (parse-cmd WHILE_FACT) init-env))) + diff --git a/semestr-2/racket/egzamin/zad1a.rkt b/semestr-2/racket/egzamin/zad1a.rkt new file mode 100644 index 0000000..a587359 --- /dev/null +++ b/semestr-2/racket/egzamin/zad1a.rkt @@ -0,0 +1,314 @@ +#lang racket + +;; ZADANIE 1 +;; ========= + +;; W tym zadaniu rozważamy język WHILE (w formie z grubsza +;; odpowiadającej tej z wykładu), z blokami deklarującymi zmienne o +;; lokalnym zakresie. + +;; Zadanie polega na dodaniu do języka procedur definiowanych na +;; zewnątrz głównego polecenia programu (podobnie jak w C, gdzie +;; główne polecenie odpowiadałoby procedurze main, czy Pascalu) — o +;; dowolnym wybranym przez siebie modelu działania. W tym celu należy: +;; · rozszerzyć składnię abstrakcyjną o składnię procedur i rozbudować odpowiednio składnię programów +;; · rozszerzyć procedurę parsowania +;; · rozszerzyć ewaluator +;; · *opisać* wybrany model działania procedur, w tym jego potencjalne zalety lub ograniczenia +;; Należy rozszerzyć poniższy szablon, a część słowną zadania umieścić +;; w komentarzu, podobnie jak niniejsze polecenie. + +;; Uwaga! Zadanie jest *bardzo* szeroko sformułowane, jest wiele +;; sensownych rozwiązań które stosowały liczne języki imperatywne w +;; historii — nie jest treścią zadania znalezienie *najlepszego*, +;; tylko swojego, które *rozumiecie*. Wybrany model działania procedur +;; *może* być relatywnie ubogi, jednak jeśli tak się zrobi, warto +;; pokazać że ma się tego świadomość w słownym opisie jego działania. + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (name) #:transparent) +(struct call-expr (name args) #:transparent) +(struct return-expr (val) #:transparent) + +(define (operator? x) + (member x '(+ * - / > < = >= <=))) + +(define (keyword? x) + (member x '(skip while if := func call return))) + +(define (expr? e) + (match e + [(const v) + (integer? v)] + [(var-expr x) + (and (symbol? x) + (not (keyword? x)))] + [(binop op l r) + (and (operator? op) + (expr? l) + (expr? r))] + [_ false])) + +(struct skip () #:transparent) +(struct assign (id exp) #:transparent) +(struct if-cmd (exp ct cf) #:transparent) +(struct while (exp cmd) #:transparent) +(struct comp (left right) #:transparent) +(struct var-in (name expr cmd) #:transparent) +(struct function (name args cmd) #:transparent) + +(define (cmd? c) + (match c + [(skip) true] + [(assign x e) (and (symbol? x) (expr? e))] + [(if-cmd e ct cf) (and (expr? e) (cmd? ct) (cmd? cf))] + [(while e c) (and (expr? e) (cmd? c))] + [(comp c1 c2) (and (cmd? c1) (cmd? c2))] + [(var-in x e c) (and (symbol? x) (expr? e) (cmd? c))] + [(function f a c) (and (symbol? f) (list? a) (andmap symbol? a) (cmd? c))])) + +(define (prog? p) + (cmd? p)) + +(define (parse-expr p) + (cond + [(number? p) (const p)] + [(and (symbol? p) + (not (keyword? p))) + (var-expr p)] + [(and (list? p) + (= 3 (length p)) + (operator? (car p))) + (binop (first p) + (parse-expr (second p)) + (parse-expr (third p)))] + [(and (list? p) ; <------ wywołanie funkcji + (= (length p) 3) + (eq? (first p) 'call) + (symbol? (second p)) + (list? (third p))) + (call-expr (second p) (map parse-expr (third p)))] + [else false])) + +(define (parse-cmd q) + (cond + [(eq? q 'skip) (skip)] + [(and (list? q) + (= (length q) 3) + (eq? (second q) ':=)) + (assign (first q) (parse-expr (third q)))] + [(and (list? q) + (= (length q) 4) + (eq? (first q) 'if)) + (if-cmd (parse-expr (second q)) (parse-cmd (third q)) (parse-cmd (fourth q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'while)) + (while (parse-expr (second q)) (parse-cmd (third q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'var) + (list? (second q)) + (= (length (second q)) 2)) + (var-in (first (second q)) + (parse-expr (second (second q))) + (parse-cmd (third q)))] + [(and (list? q) ; <------ funkcje + (= (length q) 4) + (eq? (first q) 'func) + (symbol? (second q)) + (list? (third q)) + (andmap symbol? (third q))) + (function (second q) (third q) (parse-cmd (fourth q)))] + [(and (list? q) + (= (length q) 2) + (eq? (first q) 'return)) + (return-expr (parse-expr (second q)))] + [(and (list? q) + (>= (length q) 2)) + (desugar-comp (map parse-cmd q))] + [else false])) + +(define (desugar-comp cs) + (if (null? (cdr cs)) + (car cs) + (comp (car cs) + (desugar-comp (cdr cs))))) + +(define (value? v) + (number? v)) + +(struct mem (xs) #:transparent) + +(define (mem-lookup x m) + (define (assoc-lookup xs) + (cond + [(null? xs) (error "Undefined variable" x)] + [(eq? x (caar xs)) (cdar xs)] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (mem-xs m))) + +(define (mem-defined? x m) ; <----------- !!! Sprawdz, czy x jest w ogole zdefiniowane + (define (assoc-lookup xs) + (cond + [(null? xs) #f] + [(eq? x (caar xs) #t)] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (mem-xs m))) + +(define (mem-update x v m) + (define (assoc-update xs) + (cond + [(null? xs) (error "Undefined variable" x)] + [(eq? x (caar xs)) (cons (cons x v) (cdr xs))] + [else (cons (car xs) (assoc-update (cdr xs)))])) + (mem (assoc-update (mem-xs m)))) + +(define (mem-alloc x v m) + (mem (cons (cons x v) (mem-xs m)))) + +(define (mem-drop-last m) + (cond + [(null? (mem-xs m)) + (error "Deallocating from empty memory")] + [else + (mem (cdr (mem-xs m)))])) + +(define empty-mem + (mem null)) + +(define (op->proc op) + (match op + ['+ +] + ['- -] + ['* *] + ['/ /] + ['< (lambda (x y) (if (< x y) 1 0))] + ['> (lambda (x y) (if (> x y) 1 0))] + ['= (lambda (x y) (if (= x y) 1 0))] + ['<= (lambda (x y) (if (<= x y) 1 0))] + ['>= (lambda (x y) (if (>= x y) 1 0))] + )) + +;; zał: (expr? e) i (mem? m) jest prawdą +;; (value? (eval e m)) jest prawdą +(define (eval e m) + (match e + [(const v) v] + [(var-expr x) (mem-lookup x m)] + [(binop op l r) + (let ((vl (eval l m)) + (vr (eval r m)) + (p (op->proc op))) + (p vl vr))] + [(call-expr name args) + (match (mem-lookup name m) + [(clo func-args cmd) + (if (= (length args) (length func-args)) + (let* ([func-mem (assign-values args func-args m)] + [final-mem (eval-cmd cmd func-mem)] + [ret (mem-lookup 'RETURN final-mem)]) + (if ret + ret + (error "No return statement in function" name))) + (error "Arity mismatch, function" name "takes" (length func-args) ", got" (length args)))] + [else (error "Undefined function" name)])])) + +(define (assign-values args func-args mem) + (define (iter args func-args new-mem) + (if (null? args) + new-mem + (iter (cdr args) (cdr func-args) (mem-alloc (car func-args) (eval (car args) mem) new-mem)))) + (iter args func-args mem)) + + +(struct clo (args cmd)) + +;; zał: (cmd? c) (mem? m) +;; (mem? (eval-cmd c m)) +(define (eval-cmd c m) + (if (mem-lookup 'RETURN m) + m + (match c + [(skip) m] + [(assign x e) (mem-update x (eval e m) m)] + [(if-cmd e ct cf) (if (= (eval e m) 0) + (eval-cmd cf m) + (eval-cmd ct m))] + [(while e cw) (if (= (eval e m) 0) + m + (let* ((m1 (eval-cmd cw m)) + (m2 (eval-cmd c m1))) + m2))] + [(comp c1 c2) (let* ((m1 (eval-cmd c1 m)) + (m2 (eval-cmd c2 m1))) + m2)] + [(var-in x e c) (let* ((v (eval e m)) + (m1 (mem-alloc x v m)) + (m2 (eval-cmd c m1))) + (mem-drop-last m2))] + [(function name args cmd) + (mem-alloc name (clo args cmd) m)] + [(return-expr val) + (mem-update 'RETURN (eval val m) m)] + [_ (error "Unknown command" c "— likely a syntax error")]))) + + +(define (eval-prog p m) + (let ((final-mem (eval-cmd p (mem-alloc 'RETURN #f m)))) + (with-handlers ([exn:fail? (lambda (v) (error "Undefined reference to main"))]) + (match (mem-lookup 'main final-mem) + [(clo args cmd) (mem-lookup 'RETURN (eval-cmd cmd final-mem))])))) + +(define WHILE_FACT + '({func decr (x) + {(x := (- x 1)) + (return x)}} + {func main () + {(i := 1) + (while (> t 0) + {(i := (* i t)) + (t := (call decr (t)))}) + (return i)}} + )) + +(define (fact n) + (let* ([init-env (mem-alloc 'i 1 (mem-alloc 't n empty-mem))]) + (eval-prog (parse-cmd WHILE_FACT) init-env))) + +(define TEST + '({func decr (x) (return (- x 1))} + {func main () + (var (x 1) + {(x := (+ x 1)) + (return (call decr (x)))})})) + +(define TEST2 + '({func decr (x) (return (- x 1))} + {func main () (return (call decr (3)))})) + +(define TEST3 + '({func sth (x) + {(i := -1) + (return x)}} + {func main () + {(i := 2) + (return (call sth (i)))}})) + +(define TEST4 + '(func f () + {return 1})) + +(define TEST5 + '({func f1 (x y z) + (return y)} + {func f2 (x y z) + (return (+ (+ x y) z))} + {func main () + {(if (> 4 3) + (var (x 2) + (return (call f1 (1 x 3)))) + (x := 5)) + (return (call f2 (x 3 4)))}})) + \ No newline at end of file diff --git a/semestr-2/racket/egzamin/zad1b.bak b/semestr-2/racket/egzamin/zad1b.bak new file mode 100644 index 0000000..a587359 --- /dev/null +++ b/semestr-2/racket/egzamin/zad1b.bak @@ -0,0 +1,314 @@ +#lang racket + +;; ZADANIE 1 +;; ========= + +;; W tym zadaniu rozważamy język WHILE (w formie z grubsza +;; odpowiadającej tej z wykładu), z blokami deklarującymi zmienne o +;; lokalnym zakresie. + +;; Zadanie polega na dodaniu do języka procedur definiowanych na +;; zewnątrz głównego polecenia programu (podobnie jak w C, gdzie +;; główne polecenie odpowiadałoby procedurze main, czy Pascalu) — o +;; dowolnym wybranym przez siebie modelu działania. W tym celu należy: +;; · rozszerzyć składnię abstrakcyjną o składnię procedur i rozbudować odpowiednio składnię programów +;; · rozszerzyć procedurę parsowania +;; · rozszerzyć ewaluator +;; · *opisać* wybrany model działania procedur, w tym jego potencjalne zalety lub ograniczenia +;; Należy rozszerzyć poniższy szablon, a część słowną zadania umieścić +;; w komentarzu, podobnie jak niniejsze polecenie. + +;; Uwaga! Zadanie jest *bardzo* szeroko sformułowane, jest wiele +;; sensownych rozwiązań które stosowały liczne języki imperatywne w +;; historii — nie jest treścią zadania znalezienie *najlepszego*, +;; tylko swojego, które *rozumiecie*. Wybrany model działania procedur +;; *może* być relatywnie ubogi, jednak jeśli tak się zrobi, warto +;; pokazać że ma się tego świadomość w słownym opisie jego działania. + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (name) #:transparent) +(struct call-expr (name args) #:transparent) +(struct return-expr (val) #:transparent) + +(define (operator? x) + (member x '(+ * - / > < = >= <=))) + +(define (keyword? x) + (member x '(skip while if := func call return))) + +(define (expr? e) + (match e + [(const v) + (integer? v)] + [(var-expr x) + (and (symbol? x) + (not (keyword? x)))] + [(binop op l r) + (and (operator? op) + (expr? l) + (expr? r))] + [_ false])) + +(struct skip () #:transparent) +(struct assign (id exp) #:transparent) +(struct if-cmd (exp ct cf) #:transparent) +(struct while (exp cmd) #:transparent) +(struct comp (left right) #:transparent) +(struct var-in (name expr cmd) #:transparent) +(struct function (name args cmd) #:transparent) + +(define (cmd? c) + (match c + [(skip) true] + [(assign x e) (and (symbol? x) (expr? e))] + [(if-cmd e ct cf) (and (expr? e) (cmd? ct) (cmd? cf))] + [(while e c) (and (expr? e) (cmd? c))] + [(comp c1 c2) (and (cmd? c1) (cmd? c2))] + [(var-in x e c) (and (symbol? x) (expr? e) (cmd? c))] + [(function f a c) (and (symbol? f) (list? a) (andmap symbol? a) (cmd? c))])) + +(define (prog? p) + (cmd? p)) + +(define (parse-expr p) + (cond + [(number? p) (const p)] + [(and (symbol? p) + (not (keyword? p))) + (var-expr p)] + [(and (list? p) + (= 3 (length p)) + (operator? (car p))) + (binop (first p) + (parse-expr (second p)) + (parse-expr (third p)))] + [(and (list? p) ; <------ wywołanie funkcji + (= (length p) 3) + (eq? (first p) 'call) + (symbol? (second p)) + (list? (third p))) + (call-expr (second p) (map parse-expr (third p)))] + [else false])) + +(define (parse-cmd q) + (cond + [(eq? q 'skip) (skip)] + [(and (list? q) + (= (length q) 3) + (eq? (second q) ':=)) + (assign (first q) (parse-expr (third q)))] + [(and (list? q) + (= (length q) 4) + (eq? (first q) 'if)) + (if-cmd (parse-expr (second q)) (parse-cmd (third q)) (parse-cmd (fourth q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'while)) + (while (parse-expr (second q)) (parse-cmd (third q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'var) + (list? (second q)) + (= (length (second q)) 2)) + (var-in (first (second q)) + (parse-expr (second (second q))) + (parse-cmd (third q)))] + [(and (list? q) ; <------ funkcje + (= (length q) 4) + (eq? (first q) 'func) + (symbol? (second q)) + (list? (third q)) + (andmap symbol? (third q))) + (function (second q) (third q) (parse-cmd (fourth q)))] + [(and (list? q) + (= (length q) 2) + (eq? (first q) 'return)) + (return-expr (parse-expr (second q)))] + [(and (list? q) + (>= (length q) 2)) + (desugar-comp (map parse-cmd q))] + [else false])) + +(define (desugar-comp cs) + (if (null? (cdr cs)) + (car cs) + (comp (car cs) + (desugar-comp (cdr cs))))) + +(define (value? v) + (number? v)) + +(struct mem (xs) #:transparent) + +(define (mem-lookup x m) + (define (assoc-lookup xs) + (cond + [(null? xs) (error "Undefined variable" x)] + [(eq? x (caar xs)) (cdar xs)] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (mem-xs m))) + +(define (mem-defined? x m) ; <----------- !!! Sprawdz, czy x jest w ogole zdefiniowane + (define (assoc-lookup xs) + (cond + [(null? xs) #f] + [(eq? x (caar xs) #t)] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (mem-xs m))) + +(define (mem-update x v m) + (define (assoc-update xs) + (cond + [(null? xs) (error "Undefined variable" x)] + [(eq? x (caar xs)) (cons (cons x v) (cdr xs))] + [else (cons (car xs) (assoc-update (cdr xs)))])) + (mem (assoc-update (mem-xs m)))) + +(define (mem-alloc x v m) + (mem (cons (cons x v) (mem-xs m)))) + +(define (mem-drop-last m) + (cond + [(null? (mem-xs m)) + (error "Deallocating from empty memory")] + [else + (mem (cdr (mem-xs m)))])) + +(define empty-mem + (mem null)) + +(define (op->proc op) + (match op + ['+ +] + ['- -] + ['* *] + ['/ /] + ['< (lambda (x y) (if (< x y) 1 0))] + ['> (lambda (x y) (if (> x y) 1 0))] + ['= (lambda (x y) (if (= x y) 1 0))] + ['<= (lambda (x y) (if (<= x y) 1 0))] + ['>= (lambda (x y) (if (>= x y) 1 0))] + )) + +;; zał: (expr? e) i (mem? m) jest prawdą +;; (value? (eval e m)) jest prawdą +(define (eval e m) + (match e + [(const v) v] + [(var-expr x) (mem-lookup x m)] + [(binop op l r) + (let ((vl (eval l m)) + (vr (eval r m)) + (p (op->proc op))) + (p vl vr))] + [(call-expr name args) + (match (mem-lookup name m) + [(clo func-args cmd) + (if (= (length args) (length func-args)) + (let* ([func-mem (assign-values args func-args m)] + [final-mem (eval-cmd cmd func-mem)] + [ret (mem-lookup 'RETURN final-mem)]) + (if ret + ret + (error "No return statement in function" name))) + (error "Arity mismatch, function" name "takes" (length func-args) ", got" (length args)))] + [else (error "Undefined function" name)])])) + +(define (assign-values args func-args mem) + (define (iter args func-args new-mem) + (if (null? args) + new-mem + (iter (cdr args) (cdr func-args) (mem-alloc (car func-args) (eval (car args) mem) new-mem)))) + (iter args func-args mem)) + + +(struct clo (args cmd)) + +;; zał: (cmd? c) (mem? m) +;; (mem? (eval-cmd c m)) +(define (eval-cmd c m) + (if (mem-lookup 'RETURN m) + m + (match c + [(skip) m] + [(assign x e) (mem-update x (eval e m) m)] + [(if-cmd e ct cf) (if (= (eval e m) 0) + (eval-cmd cf m) + (eval-cmd ct m))] + [(while e cw) (if (= (eval e m) 0) + m + (let* ((m1 (eval-cmd cw m)) + (m2 (eval-cmd c m1))) + m2))] + [(comp c1 c2) (let* ((m1 (eval-cmd c1 m)) + (m2 (eval-cmd c2 m1))) + m2)] + [(var-in x e c) (let* ((v (eval e m)) + (m1 (mem-alloc x v m)) + (m2 (eval-cmd c m1))) + (mem-drop-last m2))] + [(function name args cmd) + (mem-alloc name (clo args cmd) m)] + [(return-expr val) + (mem-update 'RETURN (eval val m) m)] + [_ (error "Unknown command" c "— likely a syntax error")]))) + + +(define (eval-prog p m) + (let ((final-mem (eval-cmd p (mem-alloc 'RETURN #f m)))) + (with-handlers ([exn:fail? (lambda (v) (error "Undefined reference to main"))]) + (match (mem-lookup 'main final-mem) + [(clo args cmd) (mem-lookup 'RETURN (eval-cmd cmd final-mem))])))) + +(define WHILE_FACT + '({func decr (x) + {(x := (- x 1)) + (return x)}} + {func main () + {(i := 1) + (while (> t 0) + {(i := (* i t)) + (t := (call decr (t)))}) + (return i)}} + )) + +(define (fact n) + (let* ([init-env (mem-alloc 'i 1 (mem-alloc 't n empty-mem))]) + (eval-prog (parse-cmd WHILE_FACT) init-env))) + +(define TEST + '({func decr (x) (return (- x 1))} + {func main () + (var (x 1) + {(x := (+ x 1)) + (return (call decr (x)))})})) + +(define TEST2 + '({func decr (x) (return (- x 1))} + {func main () (return (call decr (3)))})) + +(define TEST3 + '({func sth (x) + {(i := -1) + (return x)}} + {func main () + {(i := 2) + (return (call sth (i)))}})) + +(define TEST4 + '(func f () + {return 1})) + +(define TEST5 + '({func f1 (x y z) + (return y)} + {func f2 (x y z) + (return (+ (+ x y) z))} + {func main () + {(if (> 4 3) + (var (x 2) + (return (call f1 (1 x 3)))) + (x := 5)) + (return (call f2 (x 3 4)))}})) + \ No newline at end of file diff --git a/semestr-2/racket/egzamin/zad1b.rkt b/semestr-2/racket/egzamin/zad1b.rkt new file mode 100644 index 0000000..628619f --- /dev/null +++ b/semestr-2/racket/egzamin/zad1b.rkt @@ -0,0 +1,482 @@ +#lang racket + + + +;; Oświadczam, że rozwiązanie zadania egzaminacyjnego przygotowałem +;; w pełni samodzielnie, korzystając wyłącznie z materiałów do wykładu, +;; notatek, podręcznika, oraz materiałów zacytowanych w treści rozwiązania. +;; Oświadczam że nie korzystałem w żadnej formie z pomocy osób trzecich +;; w przygotowaniu rozwiązania ani też takiej pomocy nie udzielałem +;; i nie udostępniałem nikomu swojego rozwiązania. + +;; ZADANIE 1 +;; ========= + +;; W tym zadaniu rozważamy język WHILE (w formie z grubsza +;; odpowiadającej tej z wykładu), z blokami deklarującymi zmienne o +;; lokalnym zakresie. + +;; Zadanie polega na dodaniu do języka procedur definiowanych na +;; zewnątrz głównego polecenia programu (podobnie jak w C, gdzie +;; główne polecenie odpowiadałoby procedurze main, czy Pascalu) — o +;; dowolnym wybranym przez siebie modelu działania. W tym celu należy: +;; · rozszerzyć składnię abstrakcyjną o składnię procedur i rozbudować odpowiednio składnię programów +;; · rozszerzyć procedurę parsowania +;; · rozszerzyć ewaluator +;; · *opisać* wybrany model działania procedur, w tym jego potencjalne zalety lub ograniczenia +;; Należy rozszerzyć poniższy szablon, a część słowną zadania umieścić +;; w komentarzu, podobnie jak niniejsze polecenie. + +;; Uwaga! Zadanie jest *bardzo* szeroko sformułowane, jest wiele +;; sensownych rozwiązań które stosowały liczne języki imperatywne w +;; historii — nie jest treścią zadania znalezienie *najlepszego*, +;; tylko swojego, które *rozumiecie*. Wybrany model działania procedur +;; *może* być relatywnie ubogi, jednak jeśli tak się zrobi, warto +;; pokazać że ma się tego świadomość w słownym opisie jego działania. + + + + + + + +;; Postanowiłem, że struktura programów w moim języku będzie miała trochę z pythona i trochę z C. +;; Istotną decyzją którą podjąłem jest to, że wszystkie funkcje w naszym języku muszą zwracać +;; jakąś wartość (zawsze zwracają inta), łącznie z funkcją main, przy pomocy dyrektywy "return". +;; To, co zwraca main, jest tym co zwraca +;; cały program (z małym wyjątkiem, ale o tym później). Okazało się, że takie podejście +;; do sprawy jest bardzo wygodne -- nie musiałem się dzięki temu nawet przejmować +;; osobnym implementowaniem funkcji rekurencyjnych, wzajemnie rekurencyjnych +;; czy nawet zagnieżdżonych, a do tego można definiować funkcje w dowolnej kolejności! +;; Co więcej, funkcje przyjmują dowolnie wiele argumentów, również 0. +;; On top of that, do funkcji można przekazywać cokolwiek co ewaluuje się do wartości +;; Czyli mozna przekazywać wartości zmiennych, jak i dowolne wyrażenia! + +;; Oto przykładowy kod, po którym raczej jasno widać w jak wygląda nowa składnia: +(define BINOM '({func main () + (return (call binom (N K)))} + {func fact (t) + (if (= t 0) + (return 1) + ({func decr (x) (return (- x 1))} + (return (* t (call fact ((call decr (t))))))))} + {func binom (n k) + (if (= k 0) + (return 1) + (var (num (call fact (n))) + (var (den (* (call fact (k)) (call fact ((- n k))))) + (return (/ num den)))))} + )) +(define (bin n k) + (eval-prog (parse-cmd BINOM) (mem-alloc 'i 1 (mem-alloc 'N n (mem-alloc 'K k empty-mem))))) +;; Specjalnie trochę pokomplikowałem, ale widać featury naszego języka. + +;; Jak to w ogóle działa? + +;; Za każdym razem, kiedy definiuję funkcję, to do środowiska dodaję parę (nazwa funkcji . clo), +;; gdzie clo jest takim quasi-domknięciem, jest to po prostu struktura trzymająca nazwy +;; argumentów funkcji oraz jej ciało. Właśnie takie podejście bardzo dobrze +;; załatwiło łatwość w definiowaniu funkcji rekurencyjnych oraz wzajemnie rekurencyjnych i +;; zagnieżdżonych -- żadna funkcja nie zostanie wywołana, dopóki nie wywołam maina, +;; a tego wywołam dopiero po zewaluowaniu wszystkich definicji (tym samym dodaniu ich do środowiska). + +;; Takie podejście ma trochę problemów, chyba największym z nich jest to, że nie ma możliwości +;; zmiany wartości globalnych wewnątrz funkcji. Tj. możemy je zmieniać, ale zmiany będą +;; widoczne jedynie w jej lokalnym zakresie. +;; W zasadzie nie jest to aż tak bolesne -- globalne zmienne możemy traktować po prostu +;; jak argumenty wywołania funkcji main. + +;; Wywoływać funkcję mogę tylko za pomocą specjalnego wyrażenia call, +;; które jako pierwszy argument +;; przyjmuje nazwę funkcji, a jako drugi przyjmuje listę argumentów. +;; Żeby wiedzieć jak działa call, spójrzmy najpierw jak działa return. + +;; return napisane jest tak, że jeśli w jakimkolwiek miejscu funkcji +;; się na niego trafi, to reszta funkcji nie jest już wywoływana +;; (czyli tak jakbyśmy sie spodziewali). Jak on w sumie działa? +;; Na samym początku eval-prog, zanim zacznę w ogóle ewaluować definicje funkcji, +;; dodaje do środowiska specjalną zmienną o nazwie RETURN o wartości #f. +;; Jeśli w funkcji gdziekolwiek wywołam returna, to +;; zmieniam wartość RETURN w środowisku na to, co chcę zwrócić. +;; W eval-cmd za każdym razem sprawdzam jaka jest wartość RETURN. +;; Jeśli jest to #f, to pracuje jakby nigdy nic, a jeśli jest to coś innego, +;; to po prostu zwracam aktualne środowisko. +;; Zatem funkcja zwraca środowisko, w którym zmienna RETURN +;; ustawiona jest na wynik jej obliczenia. + +;; Teraz już prosto widać, że jedyne co robi call, to szuka ciała funkcji +;; w środowisku i wywołuje ją dla podanych argumentów, dostaje od tej +;; funkcji środowisko, a następnie odzyskuje wartość RETURN w zwróconym +;; przez nią środowisku. Dzięki temu po wywołaniu funkcji +;; wewnątrz innej funkcji nie zmienią się wartości żadnych zmiennych (w tym globalnych). +;; Jest to dosyć podobne do pythona -- tam inty są immutable i nie można ich wysłać przez +;; referencję. Ale możemy to robić jeśli się uprzemy np. tak: +;; {func decr (x) +;; (return (- x 1))} +;; {func main () +;; {(i := (call decr (i))) +;; (return i)} +;; Uruchomienie takiego programu ze zmienną globalną i zwróci oczywiście i-1. + +;; Mały problem którego za bardzo nie umiem rozwiązać jest taki, że jeśli gdzieś poza +;; jakąkolwiek funkcją wywołam return, to wartość którą tam zwrócę będzie +;; wartością dla całego programu, bo zmienna RETURN w środowisku zmieni swoją wartość +;; na coś innego od #f i niestety main nawet się nie wykona (na samym wstępie stwierdzi, +;; że coś zostało już zwrócone). Widać to w TEST10. Generalnie co za tym idzie, +;; między definicjami funkcji mogą być jakieś instrukcje, które zostaną +;; wywołane razem z ewaluacją programu, zanim zostanie wywołany main. + +;; Dodatkowe informacje umieściłem w komentarzach w odpowiednich miejscach pliku. +;; Na dole umieściłem kilka testów które pokazują co jak działa. + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (name) #:transparent) +(struct call-expr (name args) #:transparent) ;; wywołanie funkcji + +(define (operator? x) + (member x '(+ * - / > < = >= <=))) + +(define (keyword? x) + (member x '(skip while if := func func-rec call return))) ;; kilka nowych słów kluczowych + +(define (expr? e) + (match e + [(const v) + (integer? v)] + [(var-expr x) + (and (symbol? x) + (not (keyword? x)))] + [(binop op l r) + (and (operator? op) + (expr? l) + (expr? r))] + [(call-expr n a) + (and (symbol? n) + (list? a) + (andmap expr? a))] + [_ false])) + +(struct skip () #:transparent) +(struct assign (id exp) #:transparent) +(struct if-cmd (exp ct cf) #:transparent) +(struct while (exp cmd) #:transparent) +(struct comp (left right) #:transparent) +(struct var-in (name expr cmd) #:transparent) +(struct function (name args cmd) #:transparent) ;; dodane funkcje, funkcje rekurencyjne oraz return +(struct funcrec (name args cmd) #:transparent) +(struct return-stat (exp) #:transparent) + +(define (cmd? c) + (match c + [(skip) true] + [(assign x e) (and (symbol? x) (expr? e))] + [(if-cmd e ct cf) (and (expr? e) (cmd? ct) (cmd? cf))] + [(while e c) (and (expr? e) (cmd? c))] + [(comp c1 c2) (and (cmd? c1) (cmd? c2))] + [(var-in x e c) (and (symbol? x) (expr? e) (cmd? c))] + [(function f a c) (and (symbol? f) (list? a) (andmap symbol? a) (cmd? c))] + [(funcrec f a c) (and (symbol? f) (list? a) (andmap symbol? a) (cmd? c))] + [(return-stat exp) (expr? exp)])) + +(define (prog? p) + (cmd? p)) + +(define (parse-expr p) + (cond + [(number? p) (const p)] + [(and (symbol? p) + (not (keyword? p))) + (var-expr p)] + [(and (list? p) + (= 3 (length p)) + (operator? (car p))) + (binop (first p) + (parse-expr (second p)) + (parse-expr (third p)))] + [(and (list? p) ; <------ wywołanie funkcji + (= (length p) 3) + (eq? (first p) 'call) + (symbol? (second p)) + (list? (third p))) + (call-expr (second p) (map parse-expr (third p)))] + [else false])) + +(define (parse-cmd q) + (cond + [(eq? q 'skip) (skip)] + [(and (list? q) + (= (length q) 3) + (eq? (second q) ':=)) + (assign (first q) (parse-expr (third q)))] + [(and (list? q) + (= (length q) 4) + (eq? (first q) 'if)) + (if-cmd (parse-expr (second q)) (parse-cmd (third q)) (parse-cmd (fourth q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'while)) + (while (parse-expr (second q)) (parse-cmd (third q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'var) + (list? (second q)) + (= (length (second q)) 2)) + (var-in (first (second q)) + (parse-expr (second (second q))) + (parse-cmd (third q)))] + [(and (list? q) ; <------ funkcje + (= (length q) 4) + (eq? (first q) 'func) + (symbol? (second q)) + (list? (third q)) + (andmap symbol? (third q))) + (function (second q) (third q) (parse-cmd (fourth q)))] + [(and (list? q) ; <------ return + (= (length q) 2) + (eq? (first q) 'return)) + (return-stat (parse-expr (second q)))] + [(and (list? q) + (>= (length q) 2)) + (desugar-comp (map parse-cmd q))] + [else false])) + +(define (desugar-comp cs) + (if (null? (cdr cs)) + (car cs) + (comp (car cs) + (desugar-comp (cdr cs))))) + +(define (value? v) + (number? v)) + +(struct mem (xs) #:transparent) + +(define (mem-lookup x m) + (define (assoc-lookup xs) + (cond + [(null? xs) (error "Undefined variable" x)] + [(eq? x (caar xs)) (cdar xs)] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (mem-xs m))) + +(define (mem-update x v m) + (define (assoc-update xs) + (cond + [(null? xs) (error "Undefined variable" x)] + [(eq? x (caar xs)) (cons (cons x v) (cdr xs))] + [else (cons (car xs) (assoc-update (cdr xs)))])) + (mem (assoc-update (mem-xs m)))) + +(define (mem-alloc x v m) + (mem (cons (cons x v) (mem-xs m)))) + +(define (mem-drop-last m) + (cond + [(null? (mem-xs m)) + (error "Deallocating from empty memory")] + [else + (mem (cdr (mem-xs m)))])) + +(define empty-mem + (mem null)) + +(define (op->proc op) + (match op + ['+ +] + ['- -] + ['* *] + ['/ /] + ['< (lambda (x y) (if (< x y) 1 0))] + ['> (lambda (x y) (if (> x y) 1 0))] + ['= (lambda (x y) (if (= x y) 1 0))] + ['<= (lambda (x y) (if (<= x y) 1 0))] + ['>= (lambda (x y) (if (>= x y) 1 0))] + )) + +;; zał: (expr? e) i (mem? m) jest prawdą +;; (value? (eval e m)) jest prawdą +(define (eval e m) + (match e + [(const v) v] + [(var-expr x) (mem-lookup x m)] + [(binop op l r) + (let ((vl (eval l m)) + (vr (eval r m)) + (p (op->proc op))) + (p vl vr))] + [(call-expr name args) ;; <------ ewaluacja wywołania funkcji + (match (mem-lookup name m) + [(clo func-args cmd) + (if (= (length args) (length func-args)) ;; <------ sprawdzanie arnosci + (let* ([func-mem (assign-values args func-args m)] + [final-mem (eval-cmd cmd func-mem)] + [ret (mem-lookup 'RETURN final-mem)]) + (if ret + ret + (error "No return statement in function" name))) + (error "Arity mismatch, function" name "takes" (length func-args) "arguments, got" (length args)))] + [else (error "Undefined function" name)])])) + +(define (assign-values args func-args mem) ;; <------ przypisanie wartosci do argumentow funkcji + (define (iter args func-args new-mem) + (if (null? args) + new-mem + (iter (cdr args) (cdr func-args) (mem-alloc (car func-args) (eval (car args) mem) new-mem)))) + (iter args func-args mem)) + + +(struct clo (args cmd)) ; <----- tak trzymana jest funkcja w środowisku, tj. jako lista nazw argumentow i cialo funkcji + +;; zał: (cmd? c) (mem? m) +;; (mem? (eval-cmd c m)) +(define (eval-cmd c m) + (if (mem-lookup 'RETURN m) ; <----- jeśli RETURN jest na coś ustawione, to chcemy zrwócic pamięc + m + (match c + [(skip) m] + [(assign x e) (mem-update x (eval e m) m)] + [(if-cmd e ct cf) (if (= (eval e m) 0) + (eval-cmd cf m) + (eval-cmd ct m))] + [(while e cw) (if (= (eval e m) 0) + m + (let* ((m1 (eval-cmd cw m)) + (m2 (eval-cmd c m1))) + m2))] + [(comp c1 c2) (let* ((m1 (eval-cmd c1 m)) + (m2 (eval-cmd c2 m1))) + m2)] + [(var-in x e c) (let* ((v (eval e m)) + (m1 (mem-alloc x v m)) + (m2 (eval-cmd c m1))) + (mem-drop-last m2))] + [(function name args cmd) ; <------ dodanie ciała funkcji do środowiska + (mem-alloc name (clo args cmd) m)] + [(return-stat val) ; <------ zmiana wartości zmiennej RETURN + (mem-update 'RETURN (eval val m) m)] + [_ (error "Unknown command" c "— likely a syntax error")]))) + + +;; program ewaluowany jest tak +;; ewaluowane są wszystkie definicje funkcji, wtedy +;; ręcznie szukam definicji main i ewaluuje jej ciało i zwracam to co zwróci main. +;; zakładam, że main nie przyjmuje żadnych argumentów. +(define (eval-prog p m) + (let ((final-mem (eval-cmd p (mem-alloc 'RETURN #f m)))) + (match (mem-lookup 'main final-mem) + [(clo args cmd) + (let ((res (mem-lookup 'RETURN (eval-cmd cmd final-mem)))) + (if res res (error "No return statement in main")))]))) + +(define WHILE_FACT + '({func decr (x) + {(x := (- x 1)) + (return x)}} + {func main () + {(i := 1) + (while (> t 0) + {(i := (* i t)) + (t := (call decr (t)))}) + (return i)}} + )) + +(define (fact n) + (let* ([init-env (mem-alloc 'i 1 (mem-alloc 't n empty-mem))]) + (eval-prog (parse-cmd WHILE_FACT) init-env))) + +(define TEST + '({func decr (x) (return (- x 1))} + {func main () + (var (x 1) + {(x := (+ x 2)) + (return (call decr (x)))})})) +(define (test) (eval-prog (parse-cmd TEST) empty-mem)) + +(define TEST2 + '({func decr (x) (return (- x 1))} + {func main () (return (call decr (3)))})) +(define (test2) (eval-prog (parse-cmd TEST2) empty-mem)) + +; nie da się zmienić wartości zmiennej globalnej, zmienne są wysyłane przez kopie +(define TEST3 + '({func sth (x) + {(i := -1) + (return x)}} + {func main () + {(i := 2) + (return (call sth (i)))}})) +(define (test3) (eval-prog (parse-cmd TEST3) (mem-alloc 'i 3 empty-mem))) + +; nie ma maina, wywala błąd +(define TEST4 + '(func f () + {return 1})) +(define (test4) (eval-prog (parse-cmd TEST4) empty-mem)) + +; funkcje wieloargumentowe +(define TEST5 + '({func f1 (x y z) + (return y)} + {func f2 (x y z) + (return (+ (+ x y) z))} + {func main () + {(if (> X 3) + (var (x 2) + (return (call f1 (1 x 3)))) + (x := 5)) + (return (call f2 (x 3 4)))}})) +(define (test5) (eval-prog (parse-cmd TEST5) (mem-alloc 'x -1 (mem-alloc 'X 4 empty-mem)))) + +; Działa rekurencja!! +(define TEST6 + '({func f (x) + (if (= x 0) + (return 1) + (return (* x (call f ((- x 1))))))} + {func main () + (return (call f (X)))})) +(define (test6) (eval-prog (parse-cmd TEST6) (mem-alloc 'X 5 empty-mem))) + +; kolejnośc deklaracji funkcji nie ma znaczenia, można zagnieżdżać funkcje +(define TEST7 + '( + {func main () + (return (call f (2)))} + {func f (x) + (return (call f1 (x)))} + {func f1 (x) + {{func local-fun (x) + (return (+ 1 x))} + (return (call local-fun (x)))}})) +(define (test7) (eval-prog (parse-cmd TEST7) empty-mem)) + +; instrukcje poza jakimikolwiek funkcjami sa wykonywane przed wywołaniem main +(define TEST8 + '({func main () + (return i)} + (i := 2))) +(define (test8) (eval-prog (parse-cmd TEST8) (mem-alloc 'i 1 empty-mem))) + +; nic nie zwraca main, wywala błąd +(define TEST9 + '(func main () + (i := 1))) +(define (test9) (eval-prog (parse-cmd TEST9) (mem-alloc 'i 1 empty-mem))) + +; return poza jakąkolwiek funkcją jest wynikiem programu +(define TEST10 + '({func main () + (return i)} + (i := 2) + (return -1))) +(define (test10) (eval-prog (parse-cmd TEST10) (mem-alloc 'i 1 empty-mem))) + + +; arity mismatch +(define TEST11 + '({func main () + (return (call decr ()))} + {func decr (x) + (return (- x 1))})) +(define (test11) (eval-prog (parse-cmd TEST11) empty-mem)) diff --git a/semestr-2/racket/egzamin/zad2.bak b/semestr-2/racket/egzamin/zad2.bak new file mode 100644 index 0000000..02e2ae0 --- /dev/null +++ b/semestr-2/racket/egzamin/zad2.bak @@ -0,0 +1,119 @@ +#lang racket + +;; ZADANIE 2 +;; ========= + +;; W tym zadaniu przyjrzymy się pierwszemu "językowi programowania" +;; który widzieliśmy na zajęciach: wyrażeniom arytmetycznym. Ich +;; prostota przejawia się przede wszystkim tym że nie występują w nich +;; zmienne (a w szczególności ich wiązanie) — dlatego możemy o nich +;; wnioskować nie używając narzędzi cięższych niż te poznane na +;; wykładzie. + +;; W tym zadaniu będziemy chcieli udowodnić że nasza prosta kompilacja +;; do odwrotnej notacji polskiej jest poprawna. Konkretniej, należy +;; · sformułować zasady indukcji dla obydwu typów danych +;; reprezentujących wyrażenia (expr? i rpn-expr?) +;; · sformułować i udowodnić twierdzenie mówiące że kompilacja +;; zachowuje wartość programu, tj. że obliczenie wartości programu +;; jest równoważne skompilowaniu go do RPN i obliczeniu. +;; · sformułować i udowodnić twierdzenie mówiące że translacja z RPN +;; do wyrażeń arytmetycznych (ta która była zadaniem domowym; +;; implementacja jest poniżej) jest (prawą) odwrotnością translacji +;; do RPN (czyli że jak zaczniemy od wyrażenia i przetłumaczymy do +;; RPN i z powrotem, to dostaniemy to samo wyrażenie). +;; Swoje rozwiązanie należy wpisać na końcu tego szablonu w +;; komentarzu, podobnie do niniejszej treści zadania; proszę zadbać o +;; czytelność dowodów! + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) + +(define (operator? x) + (member x '(+ * - /))) + +(define (expr? e) + (match e + [(const v) + (integer? v)] + [(binop op l r) + (and (operator? op) + (expr? l) + (expr? r))] + [_ false])) + + +(define (value? v) + (number? v)) + +(define (op->proc op) + (match op + ['+ +] + ['- -] + ['* *] + ['/ /])) + +;; zał: (expr? e) jest prawdą +;; (value? (eval e)) jest prawdą +(define (eval e) + (match e + [(const v) v] + [(binop op l r) + (let ((vl (eval l)) + (vr (eval r)) + (p (op->proc op))) + (p vl vr))])) + +(define (rpn-expr? e) + (and (list? e) + (pair? e) + (andmap (lambda (x) (or (number? x) (operator? x))) e))) + + +(struct stack (xs)) + +(define empty-stack (stack null)) +(define (empty-stack? s) (null? (stack-xs s))) +(define (top s) (car (stack-xs s))) +(define (push a s) (stack (cons a (stack-xs s)))) +(define (pop s) (stack (cdr (stack-xs s)))) + + +(define (eval-am e s) + (cond + [(null? e) (top s)] + [(number? (car e)) (eval-am (cdr e) (push (car e) s))] + [(operator? (car e)) + (let* ((vr (top s)) + (s (pop s)) + (vl (top s)) + (s (pop s)) + (v ((op->proc (car e)) vl vr))) + (eval-am (cdr e) (push v s)))])) + +(define (rpn-eval e) + (eval-am e empty-stack)) + +(define (arith->rpn e) + (match e + [(const v) (list v)] + [(binop op l r) (append (arith->rpn l) (arith->rpn r) (list op))])) + +(define (rpn-translate e s) + (cond + [(null? e) + (top s)] + + [(number? (car e)) + (rpn-translate (cdr e) (push (const (car e)) s))] + + [(operator? (car e)) + (let* ((er (top s)) + (s (pop s)) + (el (top s)) + (s (pop s)) + (en (binop (car e) el er))) + (rpn-translate (cdr e) (push en s)))])) + +(define (rpn->arith e) + (rpn-translate e empty-stack)) \ No newline at end of file diff --git a/semestr-2/racket/egzamin/zad2.rkt b/semestr-2/racket/egzamin/zad2.rkt new file mode 100644 index 0000000..e549f07 --- /dev/null +++ b/semestr-2/racket/egzamin/zad2.rkt @@ -0,0 +1,186 @@ +#lang racket + +;; Oświadczam, że rozwiązanie zadania egzaminacyjnego przygotowałem +;; w pełni samodzielnie, korzystając wyłącznie z materiałów do wykładu, +;; notatek, podręcznika, oraz materiałów zacytowanych w treści rozwiązania. +;; Oświadczam że nie korzystałem w żadnej formie z pomocy osób trzecich +;; w przygotowaniu rozwiązania ani też takiej pomocy nie udzielałem +;; i nie udostępniałem nikomu swojego rozwiązania. + +;; ZADANIE 2 +;; ========= + +;; W tym zadaniu przyjrzymy się pierwszemu "językowi programowania" +;; który widzieliśmy na zajęciach: wyrażeniom arytmetycznym. Ich +;; prostota przejawia się przede wszystkim tym że nie występują w nich +;; zmienne (a w szczególności ich wiązanie) — dlatego możemy o nich +;; wnioskować nie używając narzędzi cięższych niż te poznane na +;; wykładzie. + +;; W tym zadaniu będziemy chcieli udowodnić że nasza prosta kompilacja +;; do odwrotnej notacji polskiej jest poprawna. Konkretniej, należy +;; · sformułować zasady indukcji dla obydwu typów danych +;; reprezentujących wyrażenia (expr? i rpn-expr?) +;; · sformułować i udowodnić twierdzenie mówiące że kompilacja +;; zachowuje wartość programu, tj. że obliczenie wartości programu +;; jest równoważne skompilowaniu go do RPN i obliczeniu. +;; · sformułować i udowodnić twierdzenie mówiące że translacja z RPN +;; do wyrażeń arytmetycznych (ta która była zadaniem domowym; +;; implementacja jest poniżej) jest (prawą) odwrotnością translacji +;; do RPN (czyli że jak zaczniemy od wyrażenia i przetłumaczymy do +;; RPN i z powrotem, to dostaniemy to samo wyrażenie). +;; Swoje rozwiązanie należy wpisać na końcu tego szablonu w +;; komentarzu, podobnie do niniejszej treści zadania; proszę zadbać o +;; czytelność dowodów! + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) + +(define (operator? x) + (member x '(+ * - /))) + +(define (expr? e) + (match e + [(const v) + (integer? v)] + [(binop op l r) + (and (operator? op) + (expr? l) + (expr? r))] + [_ false])) + + +(define (value? v) + (number? v)) + +(define (op->proc op) + (match op + ['+ +] + ['- -] + ['* *] + ['/ /])) + +;; zał: (expr? e) jest prawdą +;; (value? (eval e)) jest prawdą +(define (eval e) + (match e + [(const v) v] + [(binop op l r) + (let ((vl (eval l)) + (vr (eval r)) + (p (op->proc op))) + (p vl vr))])) + +(define (rpn-expr? e) + (and (list? e) + (pair? e) + (andmap (lambda (x) (or (number? x) (operator? x))) e))) + +;; mój kod +(define (parse-expr q) + (cond + [(integer? q) (const q)] + [(and (list? q) (= (length q) 3) (operator? (first q))) + (binop (first q) (parse-expr (second q)) (parse-expr (third q)))])) + +(struct stack (xs)) + +(define empty-stack (stack null)) +(define (empty-stack? s) (null? (stack-xs s))) +(define (top s) (car (stack-xs s))) +(define (push a s) (stack (cons a (stack-xs s)))) +(define (pop s) (stack (cdr (stack-xs s)))) + + +(define (eval-am e s) + (cond + [(null? e) (top s)] + [(number? (car e)) (eval-am (cdr e) (push (car e) s))] + [(operator? (car e)) + (let* ((vr (top s)) + (s (pop s)) + (vl (top s)) + (s (pop s)) + (v ((op->proc (car e)) vl vr))) + (eval-am (cdr e) (push v s)))])) + +(define (rpn-eval e) + (eval-am e empty-stack)) + +(define (arith->rpn e) + (match e + [(const v) (list v)] + [(binop op l r) (append (arith->rpn l) (arith->rpn r) (list op))])) + +(define (rpn-translate e s) + (cond + [(null? e) + (top s)] + + [(number? (car e)) + (rpn-translate (cdr e) (push (const (car e)) s))] + + [(operator? (car e)) + (let* ((er (top s)) + (s (pop s)) + (el (top s)) + (s (pop s)) + (en (binop (car e) el er))) + (rpn-translate (cdr e) (push en s)))])) + +(define (rpn->arith e) + (rpn-translate e empty-stack)) + + +;; W kilku miejscach pozwoliłem sobie zapomnieć że symbol operatora i operator +;; to nie to samo, ale nie ma to znaczenia w kontekście dowodów. +;; Przez ES oznaczam empty-stack +;; +;; Zasada indukcji dla expr: +;; Dla dowolnej własności P, jeśli +;; · zachodzi P((const x)) dla dowolnego x oraz +;; · dla dowolnych e1, e2 oraz operator op jeśli zachodzi P(e1), P(e2) +;; to zachodzi P((binop op e1 e2)) +;; to dla dowolnego e, jeśli zachodzi (expr? e) to zachodzi P(e) +;; +;; Zasada indukcji dla rpn (ale tego wg rpn-expr?): +;; Dla dowolnej własności P, jeśli +;; · zachodzi P(x) dla dowolnej liczby lub opeartora x oraz +;; · dla dowolnej listy liczb lub operatorów xs oraz dowolnej liczby lub +;; operatora x, jesli zachodzi P(xs), to zachodzi P((cons x xs)) +;; to dla dowolnej listy xs liczb lub operatorów zachodzi P(xs) +;; +;; +;; Tw. 1: Jeśli spełnione jest (expr? e), to (eval e) ≡ (rpn-eval (arith->rpn e)) +;; +;; D-d. Skorzystamy z zasady indukcji dla wyrażeń. +;; · Weźmy dowolną liczbę x. Wtedy jeśli e ≡ (const x), to zachodzi +;; (eval (const x)) ≡ x ≡ (rpn-eval '(x)) ≡ (rpn-eval (arith->rpn (const x))) +;; · Weźmy dowolne e1, e2 spełniające naszą tezę oraz jakiś operator op. Wtedy +;; (eval (binop op e1 e2)) ≡ +;; (op (eval e1) (eval e2)) ≡ [Z definicji eval-am] +;; (eval-am '() (push (op (eval e1) (eval e2)) ES)) ≡ +;; (eval-am '(op) (push (eval e2) (push (eval e1) ES))) ≡ [Z założenia indukcyjnego] +;; (eval-am '(op) (push (rpn-eval (arith->rpn e2)) (push (eval e1) ES))) ≡ +;; (eval-am (append (arith->rpn e2) '(op)) (push (eval e1) ES)) ≡ [Z założenia indukcyjnego] +;; (eval-am (append (arith->rpn e1) (arith->rpn e2) '(op)) ES) ≡ +;; (rpn-eval (append (arith->rpn e1) (arith->rpn e2) '(op))) ≡ [Z definicji arith->rpn] +;; (rpn-eval (arith->rpn (binop op e1 e2))) +;; Pokazaliśmy oba warunki indukcji dla wyrażeń, zatem twierdzenie prawdziwe jest +;; dla dowolnego wyrażenia e spełniającego (expr? e). +;; +;; Tw. 2: Jeśli spełnione jest (expr? e), to (rpn->arith (arith->rpn e)) ≡ e +;; +;; D-d. Skoryzstamy z indukcji dla wyrażeń. +;; · Weźmy dowolną liczbę x. Wtedy dla e ≡ (const x) zachodzi +;; (rpn->arith (arith->rpn e)) ≡ (rpn->arith '(x)) ≡ (const x) +;; · Weźmy dowolne e1, e2 dla których twierdzenie zachodzi oraz operator op. Wtedy +;; (rpn->arith (arith->rpn (binop op e1 e2))) ≡ [Z definicji arith->rpn] +;; (rpn->arith (append (arith->rpn e1) (arith->rpn e2) '(op))) ≡ +;; (rpn-translate (append (arith->rpn e1) (arith->rpn e2) '(op)) ES) ≡ [Z zał. (arith->rpn e1) ewaluuje się do liczby] +;; (rpn-translate (append (arith->rpn e2) '(op)) (push e1 ES)) ≡ [Z zał. (arith->rpn e2) ewaluuje się do liczby] +;; (rpn-translate '(op) (push e2 (push e1 ES))) ≡ [Z definicji rpn-translate] +;; (rpn-translate '() (push (binop op e1 e2) ES)) ≡ +;; (binop op e1 e2) +;; Pokazaliśmy oba warunki indukcji dla wyrażeń, zatem twierdzenie jest prawdziwe +;; dla dowolnego e spełniającego (expr? e). diff --git a/semestr-2/racket/egzamin/zad3.bak b/semestr-2/racket/egzamin/zad3.bak new file mode 100644 index 0000000..20115e9 --- /dev/null +++ b/semestr-2/racket/egzamin/zad3.bak @@ -0,0 +1,4 @@ +#lang racket + + + diff --git a/semestr-2/racket/egzamin/zad3.rkt b/semestr-2/racket/egzamin/zad3.rkt new file mode 100644 index 0000000..9bfed02 --- /dev/null +++ b/semestr-2/racket/egzamin/zad3.rkt @@ -0,0 +1,347 @@ +#lang racket + +;; Oświadczam, że rozwiązanie zadania egzaminacyjnego przygotowałem +;; w pełni samodzielnie, korzystając wyłącznie z materiałów do wykładu, +;; notatek, podręcznika, oraz materiałów zacytowanych w treści rozwiązania. +;; Oświadczam że nie korzystałem w żadnej formie z pomocy osób trzecich +;; w przygotowaniu rozwiązania ani też takiej pomocy nie udzielałem +;; i nie udostępniałem nikomu swojego rozwiązania. + +;; ZADANIE 3 +;; ========= + +;; Z gramatykami bezkontekstowymi spotkaliście się już na Wstępie do +;; Informatyki. W tym zadaniu potraktujemy je jako dane dla naszych +;; programów. + +;; Przypomnijmy, że gramatyka bezkontekstowa składa się z +;; · skończonego zbioru *symboli nieterminalnych* +;; · skończonego zbioru *symboli terminalnych* +;; · wybranego nieterminalnego symbolu startowego +;; · zbioru *produkcji*, czyli par symbol nieterminalny - lista +;; (potencjalnie pusta) symboli terminalnych lub nieterminalnych + +;; Słowo (ciąg symboli terminalnych) możemy wyprowadzić z gramatyki, +;; jeśli możemy zacząć od ciągu składającego się z symbolu startowego +;; możemy użyć skończonej liczby produkcji z gramatyki przepisując +;; symbol nieterminalny na ciąg symboli mu odpowiadających (w danej +;; produkcji). + + +;; Przykład: poprawne nawiasowania + +;; Gramatyka składa się z jednego symbolu nieterminalnego, S (który +;; jest oczywiście symbolem startowym) i dwóch symboli terminalnych +;; "(" i ")", i zawiera następujące produkcje (zwyczajowo zapisywane +;; przy użyciu strzałki; zwróćcie uwagę że pierwszy ciąg jest pusty!): +;; S -> +;; S -> SS +;; S -> (S) + +;; W często spotykanej, bardziej zwięzłej, postaci BNF moglibyśmy tę +;; gramatykę zapisać tak (dbając trochę bardziej o wizualne +;; oddzielenie symboli terminalnych i nieterminalnych): +;; S ::= "" | SS | "(" S ")" +;; Mamy tu te same produkcje, ale tylko raz zapisujemy każdą z +;; powtarzających się lewych stron. + +;; Z gramatyki tej da się wyprowadzić wszystkie poprawnie rozstawione +;; ciągi nawiasów — zobaczmy jak wyprowadzić (na jeden ze sposobów) +;; ciąg "(()())". Zaczynamy, jak zawsze, od słowa złożonego z symbolu +;; startowego i przepisujemy: +;; S -> (S) -> (SS) -> ((S)S) -> ((S)(S)) -> (()(S)) -> (()()) + + +;; Zadanie cz. 1 + +;; Zdefiniuj reprezentację gramatyki jako typu danych w +;; Rackecie. Warto zastanowić się co można uprościć względem definicji +;; matematycznej — w szczególności możemy założyć że dowolne napisy +;; (typu string) są ciągami symboli terminalnych, i że nie musimy +;; podawać jawnie zbioru nieterminali; również reprezentacja produkcji +;; gramatyki jako worka z parami wejście-wyjście niekoniecznie jest +;; najwygodniejsza. + +;; Uwaga: w tym zadaniu nie wymagamy definiowania składni konkretnej i +;; parsowania, ale bardzo polecamy wybranie jakiejś formy, żeby móc +;; sensownie przetestować swoje rozwiązanie! + + +;; "Optymalizacja" gramatyk + +;; Gramatyki, podobnie jak programy, piszą ludzie — może więc zdarzyć +;; się że znajdą się tam śmieci. Mogą one mieć dwojaką formę: symboli +;; nieterminalnych, których nie da się wyprowadzić z symbolu +;; startowego, lub symboli nieterminalnych z których nie da się +;; wyprowadzić żadnego słowa terminalnego (tj. niezawierającego +;; symboli nieterminalnych). Przykładowo, do naszej gramatyki +;; moglibyśmy dodać symbole P i Q, i produkcje: +;; S -> ")(" P +;; P -> PP "qed" +;; Q -> "abc" + +;; Mimo że nasza gramatyka wygląda inaczej na pierwszy rzut oka, tak +;; naprawdę się nie zmieniła: do symbolu Q nie możemy dojść z symbolu +;; S, a więc "abc" nigdy nie wystąpi w słowie wyprowadzalnym z +;; gramatyki. Analogicznie, z P nie da się wyprowadzić żadnego słowa, +;; które nie zawierałoby symbolu P — a zatem żadnego słowa złożonego +;; tylko z symboli terminalnych. To znaczy, że naszą gramatykę możemy +;; uprościć wyrzucając z niej symbole nieterminalne (i produkcje które +;; ich używają) do których nie da się dojść (tj. są *nieosiągalne*) i +;; te, z których nie da się ułożyć słowa terminalnego (tj. są +;; *nieproduktywne*). Jeśli z naszej rozszerzonej gramatyki wyrzucimy +;; takie symbole, dostaniemy oczywiście gramatykę początkową. + + +;; Zadanie cz. 2 + +;; Dla swojej reprezentacji gramatyki z poprzedniej części zadania +;; napisz dwie procedury: cfg-unreachable, znajdującą symbole +;; nieterminalne które są nieosiągalne z symbolu startowego, i +;; cfg-unproductive, znajdującą symbole nieterminalne które nie są +;; produktywne. Następnie użyj tych procedur żeby zdefiniować +;; procedurę cfg-optimize, która uprości daną gramatykę usuwając z +;; niej symbole nieosiągalne i nieproduktywne, a także odpowiednie +;; produkcje. + +;; Rozwiązanie wpisz w poniższym pliku, i opatrz komentarzem +;; opisującym wybraną reprezentację (i podjęte przy jej projektowaniu +;; decyzje), a także zaimplementowane w cz. 2. algorytmy. + + + + + + +;; Zadanie 1 + +;; Reprezentacja jest docyś prosta, mianowicie stworzyłem struktury +;; terminal, non-terminal, rule oraz grammar. Dwa pierwsze to +;; po prostu jednoelementowe struktury utrzymujące nazwę symboli. +;; grammar to dwuelementowa struktura, jej pierwszym elementem +;; jest symbol startowy, a następnym produkcja, czyli lista reguł (listof rule), +;; a reguły to dwuelementowe struktury (symbol niterminalny - lista nonterminali lub termianli). +;; Generalnie dzięki temu, że mam te struktury terminal oraz non-terminal +;; to symbol nieterminalne i temrinalne mogą być czykolwiek. Dodatkowo +;; dla uproszczenia w miejscach, gdzie mam pewność że chodzi mi o +;; symbol nieterminalny, to nie opakowuję go w strukturę. +;; Przykładowo rules w gramatyce może wyglądać tak: +;; (list +;; (rule 'S (list (terminal ""))) +;; (rule 'S (list (non-terminal 'S) (non-terminal 'S))) +;; (rule 'S (list (terminal "(") (non-terminal 'S) (terminal ")")))) +;; Oczywiście symbol nieterminalny nie musi być racketowym symbolem, może być czymkolwiek. +;; Podobnie z symbolami terminalnymi. Proszę również zauważyć, że dzięki +;; strukturom non-terminal oraz terminal te same racketowe obiekty mogą być jednocześnie +;; terminalami oraz nieterminalami! +;; W tych parach na pierwszym miejscu nie jest non-terminal, tylko po prostu cokolwiek +;; no i oczywiście mam wtedy pewność że musi być to non-terminal, nie ma potrzeby +;; żeby pakować go również w tę strukturę. + + +;; Postanowiłem napisać parser (make-cfg q), generuje on gramatyki w bardzo konkretny sposób, +;; trochę ograniczo to czym mogą być symbole nieterminalne oraz terminalne, +;; ale nie wydaje mi się że i tak składnia jest bardzo wygodna i mało ograniczająca. + +;; Składnia konkretna naszych gramatyk wygląda bardzo podobnie do zapisu +;; przedstawionego w treści zadania. +;; np. gramatyka nawiasowania będzie wyglądać następująco: +;; '(grammar S (S ::= "" -- SS -- "(" S ")")) +;; ale mogłaby wyglądać też tak: +;; '(grammar S (S ::= "") (S ::= SS -- "(" S ")")) +;; a np. ta nieciekawa gramatyka przedstawiona w treści zadania: +;; '(grammar S (S ::= "] [" P) (P ::= PP "qed") (Q ::= "abc")) +;; Zatem będzie to lista, która na pierwszym miejscu ma symbol 'grammar +;; na drugim miejscu ma symbol startowy +;; następnie następuje lista produkcji w formacie: +;; ::= +;; Zalety: +;; - rozróżnienie w składni konkretnej symboli nieterminalnych i terminalnych +;; przez użycie symboli i stringów pozwala na to, aby symbole terminalne nazywały się tak +;; jak terminalne, tj. "S" nie jest tym samym co 'S. +;; - składnia wydaje się bardzo wygodna w użyciu, nie ma też problemu, żeby później dopisać +;; dodatkowe reguły dla jakiegoś nieterminala, +;; - parser jest całkiem łatwy w implementacji +;; Wady: +;; - symbole nieterminalne mogą składać się jedynie z jednego symbolu, zatem nie możemy robić ich +;; zbyt wiele. Jest tak dlatego, że np. tutaj (S ::= SS) nie chodzi mi o symbol SS, tylko +;; o sąsiadujące symbole SS (jednak gdyby nie używać parsera to normalnie moglibyśmy +;; mieć wieloznakowe symbole nieterminalne!). + +;; Dla przykładu taka gramatyka: +;; '(grammar S (S ::= "" -- SS -- "(" S ")" -- Q) (Q ::= "" -- QS -- "[" Q "]")) +;; będzie reprezentowana następująco: +;; (grammar +;; 'S +;; (list +;; (rule 'S (list (terminal ""))) +;; (rule 'S (list (non-terminal 'S) (non-terminal 'S))) +;; (rule 'S (list (terminal "(") (non-terminal 'S) (terminal ")"))) +;; (rule 'S (list (non-terminal 'Q))) +;; (rule 'Q (list (terminal ""))) +;; (rule 'Q (list (non-terminal 'Q) (non-terminal 'S))) +;; (rule 'Q (list (terminal "[") (non-terminal 'Q) (terminal "]"))))) + +;; Cała reprezentacja :D +(struct non-terminal (sym) #:transparent) +(struct terminal (sym) #:transparent) +(struct rule (nt xs) #:transparent) +(struct grammar (start rules) #:transparent) + + +;; PARSER +(define SEPARATOR '--) + +(define (split-at-symb symb xs) + (define (iter left right) + (cond + [(null? right) (cons left null)] + [(eq? symb (car right)) (cons left (cdr right))] + [else (iter (cons (car right) left) (cdr right))])) + (let ([res (iter null xs)]) + (cons (reverse (car res)) (cdr res)))) + +(define (split-by-separator xs) + (let ([res (split-at-symb SEPARATOR xs)]) + (if (null? (cdr res)) + res + (cons (car res) (split-by-separator (cdr res)))))) + +;; PARSER SKŁADNI KONKRETNEJ DO JEJ REPREZENTACJI +(define (make-cfg q) + (cond + [(and (list? q) (eq? 'grammar (first q))) + (grammar (second q) (append-map make-cfg (cddr q)))] + [(and (list? q) (eq? '::= (second q))) + (let ([nt (first q)] + [rules (split-by-separator (cddr q))]) + (map (lambda (x) (rule nt x)) (map make-prod rules)))])) + +(define (symbol->list s) + (map string->symbol + (map string + (string->list (symbol->string s))))) + +(define (make-prod xs) + (cond + [(null? xs) null] + [(string? (car xs)) (cons (terminal (car xs)) (make-prod (cdr xs)))] + [(symbol? (car xs)) (append (map non-terminal (symbol->list (car xs))) (make-prod (cdr xs)))] + [else (error "Invalid syntax in production" xs)])) + + +(define sample '(S ::= "" -- SS -- "(" S ")")) +(define sample2 '(grammar S (S ::= "" -- SS -- "(" S ")" -- Q) (Q ::= "" -- QQ -- "[" Q "]"))) +(define sample3 '(grammar S + (S ::= A B -- D E) + (A ::= "a") + (B ::= "b" C) + (C ::= "c") + (D ::= "d" F) + (E ::= "e") + (F ::= "f" D))) + +(define (sample-grammar) (make-cfg sample3)) + +;; zadanie 2 + +;; korzystam z algorytmów przedstawionych w tej książce: +;; https://bit.ly/3ev0NUA, konkretnie te ze stron 50-51 +;; Pozwoliłem sobie trochę zmienić przeznaczenie funkcji cfg-unreachable oraz cfg-unproductive +;; Zamiast zwracać nieproduktywne nieterminale, zwracają właśnie produktywne +;; i analogicznie w tym drugim. Po prostu taka implementacja jest dla mnie wygodniejsza, +;; a jest bardzo nieistotną zmianą koncepcyjną. +;; Stąd zmiana nazwy na cfg-productive oraz cfg-reachable + +;; cfg-productive działa w ten sposób: +;; Jakiś nieterminal nazywamy produktywnym, jeśli ma co najmniej jedną produktywną zasadę +;; Jakąś regułę nazywamy produktywną, jeśli składa się z terminali lub produktywnych nieterminali +;; Jasno widać, że wg tej definicji te nieterminale, które nie są produktywne, są nieproduktywne +;; wg definicji zadania, a cała reszta jest produktwna. + +;; Algorytm znajdowania produktywnych nieterminali: +;; Mamy listę produktywnych nieterminali P, początkowo pustą +;; 1. Stwórz nową listę P' +;; 2. Przejdź po liście reguł +;; -> jeśli dana reguła jest produktywna (wg P), dodaj jej nieterminal do P' +;; 3. Jeśli P != P', zrób P := P' i wróć do 1. +;; 4. Zwróć P + +;; Fajne w tym algorytmie jest to, że jeśli mamy jakiś nieterminal, którego +;; używamy w jakiejś regule, ale ten nieterminal nie ma zdefiniowanej żadnej reguły, +;; to nie zostanie oznaczony jako produktywny, co jest dla nas korzystne. + +;; Algorytm znajdowania osiągalnych nieterminali: +;; Traktujemy nitereminale jak wierzchołki w grafie a reguły jako listy sąsiedztwa. +;; Terminale są liśćmi, a nieterminale węzłami. Robimy po prostu DFSa z nieterminala +;; startowego i węzły do których dotrzemy oznaczamy jako osiągalne. + +;; Wg papierka który tutaj podałem, jeśli najpierw usuniemy nieproduktywne nieterminale, +;; a w następnej kolejności nieosiągalne, to nasza gramatyka stanie się regularna. +;; Wydaje się to w miarę sensowne -- pierszy algorytm to takie odcinanie liści i odcyklanie +;; grafu, a ten drugi to po prostu DFS. + +;; przydatne predykaty -- na productive-nt mam listę symboli niterminalnych +;; (nie struktury non-terminal, tylko te symbole!) +;; które wiem że są produktywne. +;; productive? sprawdza, czy nietermial jest produktywny +;; to drugie sprawdza czy reguła jest produktywna +;; (czyli czy składa się z produktywnych nonterminali lub terminali) +(define (productive? p productive-nt) + (or (terminal? p) (member (non-terminal-sym p) productive-nt))) +(define (rule-productive? r productive-nt) + (andmap (lambda (x) (productive? x productive-nt)) r)) + +;; zwraca listę produktywnych symboli (nie nonterminali!) +(define (cfg-productive g) + (define (find-productive-nt productive-nt rules) + (cond + [(null? rules) (remove-duplicates productive-nt)] + [(rule-productive? (rule-xs (car rules)) productive-nt) + (find-productive-nt (cons (rule-nt (car rules)) productive-nt) (cdr rules))] + [else (find-productive-nt productive-nt (cdr rules))])) + (define (iter productive-nt) + (let ([new-prod-nt (find-productive-nt productive-nt (grammar-rules g))]) + (if (equal? productive-nt new-prod-nt) + productive-nt + (iter new-prod-nt)))) + (iter null)) + +;; zwraca listę osiągalnych symboli +(define (cfg-reachable g) + (define (iter verts vis) + (cond + [(null? verts) vis] + [(member (car verts) vis) (iter (cdr verts) vis)] + [else (iter (cdr verts) (dfs (car verts) vis))])) + (define (dfs v vis) + (let* ([rules (filter (lambda (r) (eq? (rule-nt r) v)) (grammar-rules g))] + [verts (append-map (lambda (r) (rule-xs r)) rules)] + [verts (filter non-terminal? verts)] + [verts (map non-terminal-sym verts)]) + (iter verts (cons v vis)))) + (dfs (grammar-start g) null)) + + +;; robi z gramatyki g gramatykę regularną +(define (cfg-optimize g) + (let* ([productive-nt (cfg-productive g)] + [productive-rules (filter (lambda (r) + (rule-productive? (rule-xs r) productive-nt)) + (grammar-rules g))] + [new-g (grammar (grammar-start g) productive-rules)] ; <----- nowa gramatyka, bez nieproduktywnych + [reachable-nt (cfg-reachable new-g)] ; reguł i symboli nieterminalnych + [res-g (grammar (grammar-start new-g) (filter ; <----- dobra gramatyka + (lambda (r) (member (rule-nt r) reachable-nt)) + (grammar-rules new-g)))]) + res-g)) + +(define (test) (cfg-optimize (make-cfg sample3))) + +;; Pokazanie że symbole nie muszą być racketowymi symbolami :) +(define (test2) (cfg-optimize + (grammar '() + (list (cons '() (list (terminal '()))) + (cons '() (list (terminal "(") (non-terminal '()) (terminal ")"))) + (cons '() (list (non-terminal '()) (non-terminal '()))))))) + \ No newline at end of file diff --git a/semestr-2/racket/egzamin/zad3a.bak b/semestr-2/racket/egzamin/zad3a.bak new file mode 100644 index 0000000..81570d0 --- /dev/null +++ b/semestr-2/racket/egzamin/zad3a.bak @@ -0,0 +1,298 @@ +#lang racket + +;; ZADANIE 3 +;; ========= + +;; Z gramatykami bezkontekstowymi spotkaliście się już na Wstępie do +;; Informatyki. W tym zadaniu potraktujemy je jako dane dla naszych +;; programów. + +;; Przypomnijmy, że gramatyka bezkontekstowa składa się z +;; · skończonego zbioru *symboli nieterminalnych* +;; · skończonego zbioru *symboli terminalnych* +;; · wybranego nieterminalnego symbolu startowego +;; · zbioru *produkcji*, czyli par symbol nieterminalny - lista +;; (potencjalnie pusta) symboli terminalnych lub nieterminalnych + +;; Słowo (ciąg symboli terminalnych) możemy wyprowadzić z gramatyki, +;; jeśli możemy zacząć od ciągu składającego się z symbolu startowego +;; możemy użyć skończonej liczby produkcji z gramatyki przepisując +;; symbol nieterminalny na ciąg symboli mu odpowiadających (w danej +;; produkcji). + + +;; Przykład: poprawne nawiasowania + +;; Gramatyka składa się z jednego symbolu nieterminalnego, S (który +;; jest oczywiście symbolem startowym) i dwóch symboli terminalnych +;; "(" i ")", i zawiera następujące produkcje (zwyczajowo zapisywane +;; przy użyciu strzałki; zwróćcie uwagę że pierwszy ciąg jest pusty!): +;; S -> +;; S -> SS +;; S -> (S) + +;; W często spotykanej, bardziej zwięzłej, postaci BNF moglibyśmy tę +;; gramatykę zapisać tak (dbając trochę bardziej o wizualne +;; oddzielenie symboli terminalnych i nieterminalnych): +;; S ::= "" | SS | "(" S ")" +;; Mamy tu te same produkcje, ale tylko raz zapisujemy każdą z +;; powtarzających się lewych stron. + +;; Z gramatyki tej da się wyprowadzić wszystkie poprawnie rozstawione +;; ciągi nawiasów — zobaczmy jak wyprowadzić (na jeden ze sposobów) +;; ciąg "(()())". Zaczynamy, jak zawsze, od słowa złożonego z symbolu +;; startowego i przepisujemy: +;; S -> (S) -> (SS) -> ((S)S) -> ((S)(S)) -> (()(S)) -> (()()) + + +;; Zadanie cz. 1 + +;; Zdefiniuj reprezentację gramatyki jako typu danych w +;; Rackecie. Warto zastanowić się co można uprościć względem definicji +;; matematycznej — w szczególności możemy założyć że dowolne napisy +;; (typu string) są ciągami symboli terminalnych, i że nie musimy +;; podawać jawnie zbioru nieterminali; również reprezentacja produkcji +;; gramatyki jako worka z parami wejście-wyjście niekoniecznie jest +;; najwygodniejsza. + +;; Uwaga: w tym zadaniu nie wymagamy definiowania składni konkretnej i +;; parsowania, ale bardzo polecamy wybranie jakiejś formy, żeby móc +;; sensownie przetestować swoje rozwiązanie! + + +;; "Optymalizacja" gramatyk + +;; Gramatyki, podobnie jak programy, piszą ludzie — może więc zdarzyć +;; się że znajdą się tam śmieci. Mogą one mieć dwojaką formę: symboli +;; nieterminalnych, których nie da się wyprowadzić z symbolu +;; startowego, lub symboli nieterminalnych z których nie da się +;; wyprowadzić żadnego słowa terminalnego (tj. niezawierającego +;; symboli nieterminalnych). Przykładowo, do naszej gramatyki +;; moglibyśmy dodać symbole P i Q, i produkcje: +;; S -> ")(" P +;; P -> PP "qed" +;; Q -> "abc" + +;; Mimo że nasza gramatyka wygląda inaczej na pierwszy rzut oka, tak +;; naprawdę się nie zmieniła: do symbolu Q nie możemy dojść z symbolu +;; S, a więc "abc" nigdy nie wystąpi w słowie wyprowadzalnym z +;; gramatyki. Analogicznie, z P nie da się wyprowadzić żadnego słowa, +;; które nie zawierałoby symbolu P — a zatem żadnego słowa złożonego +;; tylko z symboli terminalnych. To znaczy, że naszą gramatykę możemy +;; uprościć wyrzucając z niej symbole nieterminalne (i produkcje które +;; ich używają) do których nie da się dojść (tj. są *nieosiągalne*) i +;; te, z których nie da się ułożyć słowa terminalnego (tj. są +;; *nieproduktywne*). Jeśli z naszej rozszerzonej gramatyki wyrzucimy +;; takie symbole, dostaniemy oczywiście gramatykę początkową. + + +;; Zadanie cz. 2 + +;; Dla swojej reprezentacji gramatyki z poprzedniej części zadania +;; napisz dwie procedury: cfg-unreachable, znajdującą symbole +;; nieterminalne które są nieosiągalne z symbolu startowego, i +;; cfg-unproductive, znajdującą symbole nieterminalne które nie są +;; produktywne. Następnie użyj tych procedur żeby zdefiniować +;; procedurę cfg-optimize, która uprości daną gramatykę usuwając z +;; niej symbole nieosiągalne i nieproduktywne, a także odpowiednie +;; produkcje. + +;; Rozwiązanie wpisz w poniższym pliku, i opatrz komentarzem +;; opisującym wybraną reprezentację (i podjęte przy jej projektowaniu +;; decyzje), a także zaimplementowane w cz. 2. algorytmy. + + + + + + +;; Zadanie 1 + +;; Postanowiłem napisać parser, bo bez tego zadanie wydaje mi się dosyć ubogie +;; Składnia konkretna naszych gramatyk wygląda bardzo podobnie do zapisu +;; przedstawionego w treści zadania. +;; np. gramatyka nawiasowania będzie wyglądać następująco: +;; '(grammar S (S ::= "" -- SS -- "(" S ")")) +;; ale mogłaby wyglądać też tak: +;; '(grammar S (S ::= "") (S ::= SS -- "(" S ")")) +;; a np. ta nieciekawa gramatyka przedstawiona w treści zadania: +;; '(grammar S (S ::= "] [" P) (P ::= PP "qed") (Q ::= "abc")) +;; Zatem będzie to lista, która na pierwszym miejscu ma symbol 'grammar +;; na drugim miejscu ma symbol startowy +;; następnie następuje lista produkcji w formacie: +;; ::= +;; Zalety: +;; - rozróżnienie w składni konkretnej symboli nieterminalnych i terminalnych +;; przez użycie symboli i stringów pozwala na to, aby symbole terminalne nazywały się tak +;; jak terminalne, tj. "S" nie jest tym samym co 'S. +;; - składnia wydaje się bardzo wygodna w użyciu, nie ma też problemu, żeby później dopisać +;; dodatkowe produkcje dla jednego symbolu nieterminalnego, np. (S ::= "") (S ::= SS) +;; - parser jest łatwy w implementacji +;; Wady: +;; - symbole nieterminalne mogą składać się jedynie z jednego symbolu, zatem nie możemy robić ich +;; zbyt wiele + +;; Reprezentacja gramatyki: podczas parsowania gramatyki symbole i stringi wewnątrz produkcji +;; reprezentowane są przez struktury terminal oraz non-terminal. Cała gramatyka to +;; struktura dwuelementowa - pierwszym jest symbol startowy, a drugim lista par +;; Taka decyzja właśnie pozwoliła na to, że zaproponowana przeze mnie składania konkretna jest +;; bardzo prosta do sparsowania - wystarczy każdą produkcję podzielić ze względu na separator '-- +;; i do czegoś podobnego do środowisk dodawać po prostu odpowiednie pary. +;; dla przykładu taka gramatyka: +;; '(grammar S (S ::= "" -- SS -- "(" S ")" -- Q) (Q ::= "" -- QS -- "[" Q "]")) +;; będzie reprezentowana następująco: +;; (grammar +;; 'S +;; (production +;; (list +;; (list 'S (terminal "")) +;; (list 'S (non-terminal 'S) (non-terminal 'S)) +;; (list 'S (terminal "(") (non-terminal 'S) (terminal ")")) +;; (list 'S (non-terminal 'Q)) +;; (list 'Q (terminal "")) +;; (list 'Q (non-terminal 'Q) (non-terminal 'S)) +;; (list 'Q (terminal "[") (non-terminal 'Q) (terminal "]"))))) +;; Prosze zauważyć, że np. SS zostało zamienione na dwa sąsiednie nieterminalne symbole S +;; (to właśnie powód, dlaczego symbole nieterminalne mogą być jedynie jednoznakowe). + +;; Zdecydowałem się dodać strukturę production, bo wtedy łatwo można na niej operować +;; pisząc funkcje production-add, czy production-lookup itp. + + +(struct non-terminal (sym) #:transparent) +(struct terminal (sym) #:transparent) +(struct grammar (start rules) #:transparent) + +(define SEPARATOR '--) + +(define (split-at-symb symb xs) + (define (iter left right) + (cond + [(null? right) (cons left null)] + [(eq? symb (car right)) (cons left (cdr right))] + [else (iter (cons (car right) left) (cdr right))])) + (let ([res (iter null xs)]) + (cons (reverse (car res)) (cdr res)))) + +(define (split-by-separator xs) + (let ([res (split-at-symb SEPARATOR xs)]) + (if (null? (cdr res)) + res + (cons (car res) (split-by-separator (cdr res)))))) + +(define (make-cfg q) + (cond + [(and (list? q) (eq? 'grammar (first q))) + (grammar (second q) (append-map make-cfg (cddr q)))] + [(and (list? q) (eq? '::= (second q))) + (let ([nt (first q)] + [rules (split-by-separator (cddr q))]) + (map (lambda (x) (cons nt x)) (map make-prod rules)))])) + +(define (symbol->list s) + (map string->symbol + (map string + (string->list (symbol->string s))))) + +(define (make-prod xs) + (cond + [(null? xs) null] + [(string? (car xs)) (cons (terminal (car xs)) (make-prod (cdr xs)))] + [(symbol? (car xs)) (append (map non-terminal (symbol->list (car xs))) (make-prod (cdr xs)))] + [else (error "Invalid syntax in production" xs)])) + + +(define sample '(S ::= "" -- SS -- "(" S ")")) +(define sample2 '(grammar S (S ::= "" -- SS -- "(" S ")" -- Q) (Q ::= "" -- QQ -- "[" Q "]"))) +(define sample3 '(grammar S + (S ::= A B -- D E) + (A ::= "a") + (B ::= "b" C) + (C ::= "c") + (D ::= "d" F) + (E ::= "e") + (F ::= "f" D))) + +;; zadanie 2 + +;; korzystam z algorytmów przedstawionych w tej książce: +;; https://bit.ly/3ev0NUA, konkretnie te ze stron 50-51 +;; Pozwoliłem sobie trochę zmienić przeznaczenie funkcji cfg-unreachable oraz cfg-unproductive +;; Zamiast zwracać nieproduktywne nieterminale, zwracają właśnie produktywne +;; i analogicznie w tym drugim. Po prostu taka implementacja jest dla mnie wygodniejsza, +;; a jest bardzo nieistotną zmianą koncepcyjną. +;; Stąd zmiana nazwy na cfg-productive oraz cfg-reachable + +;; cfg-productive działa w ten sposób: +;; Jakiś nieterminal nazywamy produktywnym, jeśli ma co najmniej jedną produktywną zasadę +;; Jakąś zasadę nazywamy produktywną, jeśli składa się z terminali oraz produktywnych nieterminali +;; Jasno widać, że wg tej definicji te nieterminale, które nie są produktywne, są nieproduktywne +;; wg definicji zadania, a cała reszta jest produktwna. + +;; Algorytm znajdowania produktywnych nieterminali: +;; Mamy listę produktywnych nieterminali P, początkowo pustą +;; 1. Stwórz nową listę P' +;; 2. Przejdź po liście produkcji +;; -> jeśli dana produkcja jest produktywna (wg P), dodaj jej nieterminal do P' +;; 3. Jeśli P != P', zrób P := P' i wróć do 1. +;; 4. Zwróć P + +;; Fajne w tym algorytmie jest to, że jeśli mamy jakiś nieterminal, którego +;; używamy w jakiejś produkcji, ale ten nieterminal nie ma zdefiniowanej swojej produkcji +;; to nie zostanie oznaczony jako produktywny, co jest dla nas korzystne + +;; Algorytm znajdowania osiągalnych nieterminali: +;; Traktujemy nitereminale jak wierzchołki w grafie a zasady jako listy sąsiedztwa. +;; Terminale są liśćmi, a nieterminale węzłami. Robimy po prostu DFSa z nieterminalu +;; startowego i węzły do których dotrzemy oznaczamy jako osiągalne. + +;; Wg papierka który tutaj podałem, jeśli najpierw usuniemy nieproduktywne nieterminale, +;; a w następnej kolejności nieosiągalne, to nasza gramatyka stanie się regularna. + +(define (productive? p productive-nt) + (or (terminal? p) (member (non-terminal-sym p) productive-nt))) +(define (rule-productive? r productive-nt) + (andmap (lambda (x) (productive? x productive-nt)) r)) + +(define (cfg-productive g) + (define (find-productive-nt productive-nt rules) + (cond + [(null? rules) (remove-duplicates productive-nt)] + [(rule-productive? (cdar rules) productive-nt) + (find-productive-nt (cons (caar rules) productive-nt) (cdr rules))] + [else (find-productive-nt productive-nt (cdr rules))])) + (define (iter productive-nt) + (let ([new-prod-nt (find-productive-nt productive-nt (grammar-rules g))]) + (if (equal? productive-nt new-prod-nt) + productive-nt + (iter new-prod-nt)))) + (iter null)) + +(define (cfg-reachable g) + (define (iter verts vis) + (cond + [(null? verts) vis] + [(member (car verts) vis) (iter (cdr verts) vis)] + [else (iter (cdr verts) (dfs (car verts) vis))])) + (define (dfs v vis) + (display v) + (newline) + (let* ([rules (filter (lambda (r) (eq? (car r) v)) (grammar-rules g))] + [verts (append-map (lambda (r) (cdr r)) rules)] + [verts (filter non-terminal? verts)] + [verts (map non-terminal-sym verts)]) + (iter verts (cons v vis)))) + (dfs (grammar-start g) null)) + +(define (cfg-optimize g) + (let* ([productive-nt (cfg-productive g)] + [productive-rules (filter (lambda (r) + (rule-productive? (cdr r) productive-nt)) + (grammar-rules g))] + [new-g (grammar (grammar-start g) productive-rules)] + [reachable-nt (cfg-reachable new-g)] + [res-g (grammar (grammar-start new-g) (filter + (lambda (r) (member (car r) reachable-nt)) + (grammar-rules new-g)))]) + res-g)) + \ No newline at end of file diff --git a/semestr-2/racket/egzamin/zad3a.rkt b/semestr-2/racket/egzamin/zad3a.rkt new file mode 100644 index 0000000..eaa6645 --- /dev/null +++ b/semestr-2/racket/egzamin/zad3a.rkt @@ -0,0 +1,301 @@ +#lang racket + +;; ZADANIE 3 +;; ========= + +;; Z gramatykami bezkontekstowymi spotkaliście się już na Wstępie do +;; Informatyki. W tym zadaniu potraktujemy je jako dane dla naszych +;; programów. + +;; Przypomnijmy, że gramatyka bezkontekstowa składa się z +;; · skończonego zbioru *symboli nieterminalnych* +;; · skończonego zbioru *symboli terminalnych* +;; · wybranego nieterminalnego symbolu startowego +;; · zbioru *produkcji*, czyli par symbol nieterminalny - lista +;; (potencjalnie pusta) symboli terminalnych lub nieterminalnych + +;; Słowo (ciąg symboli terminalnych) możemy wyprowadzić z gramatyki, +;; jeśli możemy zacząć od ciągu składającego się z symbolu startowego +;; możemy użyć skończonej liczby produkcji z gramatyki przepisując +;; symbol nieterminalny na ciąg symboli mu odpowiadających (w danej +;; produkcji). + + +;; Przykład: poprawne nawiasowania + +;; Gramatyka składa się z jednego symbolu nieterminalnego, S (który +;; jest oczywiście symbolem startowym) i dwóch symboli terminalnych +;; "(" i ")", i zawiera następujące produkcje (zwyczajowo zapisywane +;; przy użyciu strzałki; zwróćcie uwagę że pierwszy ciąg jest pusty!): +;; S -> +;; S -> SS +;; S -> (S) + +;; W często spotykanej, bardziej zwięzłej, postaci BNF moglibyśmy tę +;; gramatykę zapisać tak (dbając trochę bardziej o wizualne +;; oddzielenie symboli terminalnych i nieterminalnych): +;; S ::= "" | SS | "(" S ")" +;; Mamy tu te same produkcje, ale tylko raz zapisujemy każdą z +;; powtarzających się lewych stron. + +;; Z gramatyki tej da się wyprowadzić wszystkie poprawnie rozstawione +;; ciągi nawiasów — zobaczmy jak wyprowadzić (na jeden ze sposobów) +;; ciąg "(()())". Zaczynamy, jak zawsze, od słowa złożonego z symbolu +;; startowego i przepisujemy: +;; S -> (S) -> (SS) -> ((S)S) -> ((S)(S)) -> (()(S)) -> (()()) + + +;; Zadanie cz. 1 + +;; Zdefiniuj reprezentację gramatyki jako typu danych w +;; Rackecie. Warto zastanowić się co można uprościć względem definicji +;; matematycznej — w szczególności możemy założyć że dowolne napisy +;; (typu string) są ciągami symboli terminalnych, i że nie musimy +;; podawać jawnie zbioru nieterminali; również reprezentacja produkcji +;; gramatyki jako worka z parami wejście-wyjście niekoniecznie jest +;; najwygodniejsza. + +;; Uwaga: w tym zadaniu nie wymagamy definiowania składni konkretnej i +;; parsowania, ale bardzo polecamy wybranie jakiejś formy, żeby móc +;; sensownie przetestować swoje rozwiązanie! + + +;; "Optymalizacja" gramatyk + +;; Gramatyki, podobnie jak programy, piszą ludzie — może więc zdarzyć +;; się że znajdą się tam śmieci. Mogą one mieć dwojaką formę: symboli +;; nieterminalnych, których nie da się wyprowadzić z symbolu +;; startowego, lub symboli nieterminalnych z których nie da się +;; wyprowadzić żadnego słowa terminalnego (tj. niezawierającego +;; symboli nieterminalnych). Przykładowo, do naszej gramatyki +;; moglibyśmy dodać symbole P i Q, i produkcje: +;; S -> ")(" P +;; P -> PP "qed" +;; Q -> "abc" + +;; Mimo że nasza gramatyka wygląda inaczej na pierwszy rzut oka, tak +;; naprawdę się nie zmieniła: do symbolu Q nie możemy dojść z symbolu +;; S, a więc "abc" nigdy nie wystąpi w słowie wyprowadzalnym z +;; gramatyki. Analogicznie, z P nie da się wyprowadzić żadnego słowa, +;; które nie zawierałoby symbolu P — a zatem żadnego słowa złożonego +;; tylko z symboli terminalnych. To znaczy, że naszą gramatykę możemy +;; uprościć wyrzucając z niej symbole nieterminalne (i produkcje które +;; ich używają) do których nie da się dojść (tj. są *nieosiągalne*) i +;; te, z których nie da się ułożyć słowa terminalnego (tj. są +;; *nieproduktywne*). Jeśli z naszej rozszerzonej gramatyki wyrzucimy +;; takie symbole, dostaniemy oczywiście gramatykę początkową. + + +;; Zadanie cz. 2 + +;; Dla swojej reprezentacji gramatyki z poprzedniej części zadania +;; napisz dwie procedury: cfg-unreachable, znajdującą symbole +;; nieterminalne które są nieosiągalne z symbolu startowego, i +;; cfg-unproductive, znajdującą symbole nieterminalne które nie są +;; produktywne. Następnie użyj tych procedur żeby zdefiniować +;; procedurę cfg-optimize, która uprości daną gramatykę usuwając z +;; niej symbole nieosiągalne i nieproduktywne, a także odpowiednie +;; produkcje. + +;; Rozwiązanie wpisz w poniższym pliku, i opatrz komentarzem +;; opisującym wybraną reprezentację (i podjęte przy jej projektowaniu +;; decyzje), a także zaimplementowane w cz. 2. algorytmy. + + + + + + +;; Zadanie 1 + +;; Postanowiłem napisać parser, bo bez tego zadanie wydaje mi się dosyć ubogie +;; Składnia konkretna naszych gramatyk wygląda bardzo podobnie do zapisu +;; przedstawionego w treści zadania. +;; np. gramatyka nawiasowania będzie wyglądać następująco: +;; '(grammar S (S ::= "" -- SS -- "(" S ")")) +;; ale mogłaby wyglądać też tak: +;; '(grammar S (S ::= "") (S ::= SS -- "(" S ")")) +;; a np. ta nieciekawa gramatyka przedstawiona w treści zadania: +;; '(grammar S (S ::= "] [" P) (P ::= PP "qed") (Q ::= "abc")) +;; Zatem będzie to lista, która na pierwszym miejscu ma symbol 'grammar +;; na drugim miejscu ma symbol startowy +;; następnie następuje lista produkcji w formacie: +;; ::= +;; Zalety: +;; - rozróżnienie w składni konkretnej symboli nieterminalnych i terminalnych +;; przez użycie symboli i stringów pozwala na to, aby symbole terminalne nazywały się tak +;; jak terminalne, tj. "S" nie jest tym samym co 'S. +;; - składnia wydaje się bardzo wygodna w użyciu, nie ma też problemu, żeby później dopisać +;; dodatkowe produkcje dla jednego symbolu nieterminalnego, np. (S ::= "") (S ::= SS) +;; - parser jest łatwy w implementacji +;; Wady: +;; - symbole nieterminalne mogą składać się jedynie z jednego symbolu, zatem nie możemy robić ich +;; zbyt wiele + +;; Reprezentacja gramatyki: podczas parsowania gramatyki symbole i stringi wewnątrz produkcji +;; reprezentowane są przez struktury terminal oraz non-terminal. Cała gramatyka to +;; struktura dwuelementowa - pierwszym jest symbol startowy, a drugim lista par +;; Taka decyzja właśnie pozwoliła na to, że zaproponowana przeze mnie składania konkretna jest +;; bardzo prosta do sparsowania - wystarczy każdą produkcję podzielić ze względu na separator '-- +;; i do czegoś podobnego do środowisk dodawać po prostu odpowiednie pary. +;; dla przykładu taka gramatyka: +;; '(grammar S (S ::= "" -- SS -- "(" S ")" -- Q) (Q ::= "" -- QS -- "[" Q "]")) +;; będzie reprezentowana następująco: +;; (grammar +;; 'S +;; (production +;; (list +;; (list 'S (terminal "")) +;; (list 'S (non-terminal 'S) (non-terminal 'S)) +;; (list 'S (terminal "(") (non-terminal 'S) (terminal ")")) +;; (list 'S (non-terminal 'Q)) +;; (list 'Q (terminal "")) +;; (list 'Q (non-terminal 'Q) (non-terminal 'S)) +;; (list 'Q (terminal "[") (non-terminal 'Q) (terminal "]"))))) +;; Prosze zauważyć, że np. SS zostało zamienione na dwa sąsiednie nieterminalne symbole S +;; (to właśnie powód, dlaczego symbole nieterminalne mogą być jedynie jednoznakowe). + +;; Zdecydowałem się dodać strukturę production, bo wtedy łatwo można na niej operować +;; pisząc funkcje production-add, czy production-lookup itp. + + +(struct non-terminal (sym) #:transparent) +(struct terminal (sym) #:transparent) +(struct grammar (start rules) #:transparent) + +(define SEPARATOR '--) + +(define (make-cfg q) + (cond + [(and (list? q) (eq? 'grammar (first q))) + (grammar (second q) (append-map make-cfg (cddr q)))] + [(and (list? q) (eq? '::= (second q))) + (let ([nt (first q)] + [rules (split-by-separator (cddr q))]) + (map (lambda (x) (cons nt x)) (map make-rules rules)))] + [else (error "MAKE-CFG -- Parse error, unknown token" q)])) + +(define (make-cfg start rules) + (grammar start (make-rules rules))) + +(define (make-rules xs) + (cond + [(null? xs) null] + [(string? (car xs)) (cons (terminal (car xs)) (make-rules (cdr xs)))] + [(symbol? (car xs)) (append (map non-terminal (symbol->list (car xs))) (make-rules (cdr xs)))] + [else (error "Invalid syntax in production" xs)])) + +(define (split-at-symb symb xs) + (define (iter left right) + (cond + [(null? right) (cons left null)] + [(eq? symb (car right)) (cons left (cdr right))] + [else (iter (cons (car right) left) (cdr right))])) + (let ([res (iter null xs)]) + (cons (reverse (car res)) (cdr res)))) + +(define (split-by-separator xs) + (let ([res (split-at-symb SEPARATOR xs)]) + (if (null? (cdr res)) + res + (cons (car res) (split-by-separator (cdr res)))))) + +(define (symbol->list s) + (map string->symbol + (map string + (string->list (symbol->string s))))) + +(define sample '(S ::= "" -- SS -- "(" S ")")) +(define sample2 '(grammar S (S ::= "" -- SS -- "(" S ")" -- Q) (Q ::= "" -- QQ -- "[" Q "]"))) +(define sample3 '(grammar S + (S ::= A B -- D E) + (A ::= "a") + (B ::= "b" C) + (C ::= "c") + (D ::= "d" F) + (E ::= "e") + (F ::= "f" D))) + +;; zadanie 2 + +;; korzystam z algorytmów przedstawionych w tej książce: +;; https://bit.ly/3ev0NUA, konkretnie te ze stron 50-51 +;; Pozwoliłem sobie trochę zmienić przeznaczenie funkcji cfg-unreachable oraz cfg-unproductive +;; Zamiast zwracać nieproduktywne nieterminale, zwracają właśnie produktywne +;; i analogicznie w tym drugim. Po prostu taka implementacja jest dla mnie wygodniejsza, +;; a jest bardzo nieistotną zmianą koncepcyjną. +;; Stąd zmiana nazwy na cfg-productive oraz cfg-reachable + +;; cfg-productive działa w ten sposób: +;; Jakiś nieterminal nazywamy produktywnym, jeśli ma co najmniej jedną produktywną zasadę +;; Jakąś zasadę nazywamy produktywną, jeśli składa się z terminali oraz produktywnych nieterminali +;; Jasno widać, że wg tej definicji te nieterminale, które nie są produktywne, są nieproduktywne +;; wg definicji zadania, a cała reszta jest produktwna. + +;; Algorytm znajdowania produktywnych nieterminali: +;; Mamy listę produktywnych nieterminali P, początkowo pustą +;; 1. Stwórz nową listę P' +;; 2. Przejdź po liście produkcji +;; -> jeśli dana produkcja jest produktywna (wg P), dodaj jej nieterminal do P' +;; 3. Jeśli P != P', zrób P := P' i wróć do 1. +;; 4. Zwróć P + +;; Fajne w tym algorytmie jest to, że jeśli mamy jakiś nieterminal, którego +;; używamy w jakiejś produkcji, ale ten nieterminal nie ma zdefiniowanej swojej produkcji +;; to nie zostanie oznaczony jako produktywny, co jest dla nas korzystne + +;; Algorytm znajdowania osiągalnych nieterminali: +;; Traktujemy nitereminale jak wierzchołki w grafie a zasady jako listy sąsiedztwa. +;; Terminale są liśćmi, a nieterminale węzłami. Robimy po prostu DFSa z nieterminalu +;; startowego i węzły do których dotrzemy oznaczamy jako osiągalne. + +;; Wg papierka który tutaj podałem, jeśli najpierw usuniemy nieproduktywne nieterminale, +;; a w następnej kolejności nieosiągalne, to nasza gramatyka stanie się regularna. + +(define (productive? p productive-nt) + (or (terminal? p) (member (non-terminal-sym p) productive-nt))) +(define (rule-productive? r productive-nt) + (andmap (lambda (x) (productive? x productive-nt)) r)) + +(define (cfg-productive g) + (define (find-productive-nt productive-nt rules) + (cond + [(null? rules) (remove-duplicates productive-nt)] + [(rule-productive? (cdar rules) productive-nt) + (find-productive-nt (cons (caar rules) productive-nt) (cdr rules))] + [else (find-productive-nt productive-nt (cdr rules))])) + (define (iter productive-nt) + (let ([new-prod-nt (find-productive-nt productive-nt (grammar-rules g))]) + (if (equal? productive-nt new-prod-nt) + productive-nt + (iter new-prod-nt)))) + (iter null)) + +(define (cfg-reachable g) + (define (iter verts vis) + (cond + [(null? verts) vis] + [(member (car verts) vis) (iter (cdr verts) vis)] + [else (iter (cdr verts) (dfs (car verts) vis))])) + (define (dfs v vis) + (display v) + (newline) + (let* ([rules (filter (lambda (r) (eq? (car r) v)) (grammar-rules g))] + [verts (append-map (lambda (r) (cdr r)) rules)] + [verts (filter non-terminal? verts)] + [verts (map non-terminal-sym verts)]) + (iter verts (cons v vis)))) + (dfs (grammar-start g) null)) + +(define (cfg-optimize g) + (let* ([productive-nt (cfg-productive g)] + [productive-rules (filter (lambda (r) + (rule-productive? (cdr r) productive-nt)) + (grammar-rules g))] + [new-g (grammar (grammar-start g) productive-rules)] + [reachable-nt (cfg-reachable new-g)] + [res-g (grammar (grammar-start new-g) (filter + (lambda (r) (member (car r) reachable-nt)) + (grammar-rules new-g)))]) + res-g)) + \ No newline at end of file diff --git a/semestr-2/racket/l10z18/solution.bak b/semestr-2/racket/l10z18/solution.bak new file mode 100644 index 0000000..02eb770 --- /dev/null +++ b/semestr-2/racket/l10z18/solution.bak @@ -0,0 +1,363 @@ +#lang racket + +;; Składnia abstrakcyjna +(struct const (val) #:transparent) +(struct var-expr (name) #:transparent) +(struct let-expr (id bound body) #:transparent) +(struct letrec-expr (id bound body) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct lambda-expr (arg body) #:transparent) +(struct app-expr (fun arg) #:transparent) + +(define (keyword s) + (member s '(true false null and or if cond else lambda let letrec))) + +(define (expr? e) + (match e + [(const n) (or (number? n) + (boolean? n) + (null? n) + (string? n))] + [(var-expr id) (symbol? id)] + [(let-expr x e1 e2 ) (and (symbol? x) + (expr? e1) + (expr? e2))] + [(letrec-expr x e1 e2) (and (symbol? x) + (expr? e1) + (expr? e2))] + [(if-expr eb et ef) (and (expr? eb) + (expr? et) + (expr? ef))] + [(lambda-expr x e) (and (symbol? x) + (expr? e))] + [(app-expr ef ea) (and (expr? ef) + (expr? ea))] + [_ false])) + +;; Parsowanie (zacytowane wyrażenie -> składnia abstrakcyjna) +(define (parse q) + (cond + [(number? q) (const q)] + [(string? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (const null)] + [(and (symbol? q) + (not (keyword q))) + (var-expr q)] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'let) + (list? (second q)) + (= (length (second q)) 2) + (symbol? (first (second q)))) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'letrec) + (list? (second q)) + (= (length (second q)) 2) + (symbol? (first (second q)))) + (letrec-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) + (= (length q) 4) + (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) + (pair? q) + (eq? (first q) 'and)) + (desugar-and (map parse (cdr q)))] + [(and (list? q) + (pair? q) + (eq? (first q) 'or)) + (desugar-or (map parse (cdr q)))] + [(and (list? q) + (>= (length q) 2) + (eq? (first q) 'cond)) + (parse-cond (cdr q))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'lambda) + (list? (second q)) + (andmap symbol? (second q)) + (cons? (second q))) + (desugar-lambda (second q) (parse (third q)))] + [(and (list? q) + (>= (length q) 2)) + (desugar-app (parse (first q)) (map parse (cdr q)))] + [else (error "Unrecognized token:" q)])) + +(define (parse-cond qs) + (match qs + [(list (list 'else q)) + (parse q)] + + [(list (list q _)) + (error "Expected 'else' in last branch but found:" q)] + + [(cons (list qb qt) qs) + (if-expr (parse qb) (parse qt) (parse-cond qs))])) + +(define (desugar-and es) + (if (null? es) + (const true) + (if-expr (car es) (desugar-and (cdr es)) (const false)))) + +(define (desugar-or es) + (if (null? es) + (const false) + (if-expr (car es) (const true) (desugar-or (cdr es))))) + +(define (desugar-lambda xs e) + (if (null? xs) + e + (lambda-expr (car xs) (desugar-lambda (cdr xs) e)))) + +(define (desugar-app e es) + (if (null? es) + e + (desugar-app (app-expr e (car es)) (cdr es)))) + +;; Środowiska +(struct blackhole ()) +(struct environ (xs)) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (mcons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) + (error "Unknown identifier" x)] + [(eq? x (mcar (car xs))) + (let ((v (mcdr (car xs)))) + (if (blackhole? v) + (error "Jumped into blackhole at" x) + v))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) +(define (env-update! x v env) + (define (assoc-update xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (mcar (car xs))) + (set-mcdr! (car xs) v)] + [else (assoc-update (cdr xs))])) + (assoc-update (environ-xs env))) + +;; Domknięcia +(struct clo (arg body env)) + +;; Procedury wbudowane, gdzie +;; proc — Racketowa procedura którą należy uruchomić +;; args — lista dotychczas dostarczonych argumentów +;; pnum — liczba brakujących argumentów (> 0) +;; W ten sposób pozwalamy na częściową aplikację Racketowych procedur +;; — zauważmy że zawsze znamy pnum, bo w naszym języku arność +;; procedury jest ustalona z góry +(struct builtin (proc args pnum) #:transparent) + +;; Pomocnicze konstruktory procedur unarnych i binarnych +(define (builtin/1 p) + (builtin (lambda (x) (return (p x))) null 1)) +(define (builtin/2 p) + (builtin (lambda (x y) (return (p x y))) null 2)) + +;; Procedury +(define (proc? v) + (or (and (clo? v) + (symbol? (clo-arg v)) + (expr? (clo-body v)) + (environ? (clo-env v))) + (and (builtin? v) + (procedure? (builtin-proc v)) + (andmap value? (builtin-args v)) + (natural? (builtin-pnum v)) + (> (builtin-pnum v) 0)))) + +;; Definicja typu wartości +(define (value? v) + (or (number? v) + (boolean? v) + (null? v) + (string? v) + (and (cons? v) + (value? (car v)) + (value? (cdr v))) + (proc? v))) + +;; Środowisko początkowe (przypisujące procedury wbudowane ich nazwom) + +(define start-env + (foldl (lambda (p env) (env-add (first p) (second p) env)) + env-empty + `((+ ,(builtin/2 +)) + (- ,(builtin/2 -)) + (* ,(builtin/2 *)) + (/ ,(builtin/2 /)) + (~ ,(builtin/1 -)) + (< ,(builtin/2 <)) + (> ,(builtin/2 >)) + (= ,(builtin/2 =)) + (<= ,(builtin/2 <=)) + (>= ,(builtin/2 >=)) + (not ,(builtin/1 not)) + (cons ,(builtin/2 cons)) + (car ,(builtin/1 car)) + (cdr ,(builtin/1 cdr)) + (pair? ,(builtin/1 cons?)) + (null? ,(builtin/1 null?)) + (boolean? ,(builtin/1 boolean?)) + (number? ,(builtin/1 number?)) + (procedure? ,(builtin/1 (lambda (x) (or (clo? x) (builtin? x))))) + (string? ,(builtin/1 string?)) + (string-= ,(builtin/2 string=?)) + ;; and so on, and so on + ))) + +;; Efekt + +(define (effect-builtin/1 p) + (builtin p null 1)) +(define (effect-builtin/2 p) + (builtin p null 2)) + +(define effect-env + (foldl (lambda (p env) (env-add (first p) (second p) env)) + start-env + `((choose ,(effect-builtin/2 (lambda (x y) (list x y)))) + ))) + +(define (bind c k) (append-map k c)) + +(define (return x) (list x)) + +;; Ewaluator +(define (eval-env e env) + (match e + [(const n) + (return n)] + + [(var-expr x) + (return (env-lookup x env))] + + [(let-expr x e1 e2) + (bind (eval-env e1 env) (lambda (v1) + (eval-env e2 (env-add x v1 env))))] + + [(letrec-expr f ef eb) + (let ((new-env (env-add f (blackhole) env))) + (bind (eval-env ef new-env) (lambda (vf) + (env-update! f vf new-env) + (eval-env eb new-env))))] + + [(if-expr eb et ef) + (bind (eval-env eb env) (lambda (vb) + (match vb + [#t (eval-env et env)] + [#f (eval-env ef env)] + [v (error "Not a boolean:" v)])))] + + [(lambda-expr x e) + (return (clo x e env))] + + [(app-expr ef ea) + (bind (eval-env ef env) (lambda (vf) + (bind (eval-env ea env) (lambda (va) + (match vf + [(clo x e env) + (eval-env e (env-add x va env))] + [(builtin p args nm) + (if (= nm 1) + (apply p (reverse (cons va args))) + (return (builtin p (cons va args) (- nm 1))))] + [_ (error "Not a function:" vf)])))))])) + +(define (eval e) + (eval-env e effect-env)) + + +;; Przykladowy program + +(define PROGRAM + '((if (choose true false) (lambda (x) x) (lambda (x) (+ x 1))) (choose 1 2))) + + +;; REPL — interpreter interaktywny (read-eval-print loop) + +;; dodajemy składnię na wiązanie zmiennych "na poziomie interpretera" +;; i komendę wyjścia "exit" ... +(struct letrec-repl (id expr)) +(struct let-repl (id expr)) +(struct exit-repl ()) + +;; ... a także rozszerzoną procedurę parsującą te dodatkowe komendy i +;; prostą obsługę błędów +(define (parse-repl q) + (with-handlers + ([exn? (lambda (exn) + (display "Parse error! ") + (displayln (exn-message exn)))]) + (cond + [(eq? q 'exit) (exit-repl)] + [(and (list? q) + (= 3 (length q)) + (eq? (first q) 'let)) + (let-repl (second q) (parse (third q)))] + [(and (list? q) + (= 3 (length q)) + (eq? (first q) 'letrec)) + (letrec-repl (second q) (parse (third q)))] + [else (parse q)]))) + +;; trochę zamieszania w procedurze eval-repl wynika z rudymentarnej +;; obsługi błędów: nie chcemy żeby błąd w interpretowanym programie +;; kończył działanie całego interpretera! +(define (eval-repl c env continue) + (define (eval-with-err e env) + (with-handlers + ([exn? (lambda (exn) + (display "Error! ") + (displayln (exn-message exn)))]) + (eval-env e env))) + (match c + [(exit-repl) + (void)] + + [(let-repl x e) + (let ((v (eval-with-err e env))) + (if (void? v) + (continue env) + (continue (env-add x v env))))] + + [(letrec-repl f e) + (let* ((new-env (env-add f (blackhole) env)) + (v (eval-with-err e new-env))) + (if (void? v) + (continue env) + (begin + (env-update! f v new-env) + (continue new-env))))] + + [_ + (let ((v (eval-with-err c env))) + (unless (void? v) + (displayln v)) + (continue env))])) + +;; I w końcu interaktywny interpreter +(define (repl) + (define (go env) + (display "FUN > ") + (let* ((q (read)) + (c (parse-repl q))) + (if (void? c) + (go env) + (eval-repl c env go)))) + (displayln "Welcome to the FUN functional language interpreter!") + (go start-env)) \ No newline at end of file diff --git a/semestr-2/racket/l10z18/solution.rkt b/semestr-2/racket/l10z18/solution.rkt new file mode 100644 index 0000000..7adcea4 --- /dev/null +++ b/semestr-2/racket/l10z18/solution.rkt @@ -0,0 +1,409 @@ +#lang racket + +;; Składnia abstrakcyjna +(struct const (val) #:transparent) +(struct var-expr (name) #:transparent) +(struct let-expr (id bound body) #:transparent) +(struct letrec-expr (id bound body) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct lambda-expr (arg body) #:transparent) +(struct app-expr (fun arg) #:transparent) + +(provide parse eval norm) + +(define (keyword s) + (member s '(true false null and or if cond else lambda let letrec))) + +(define (expr? e) + (match e + [(const n) (or (number? n) + (boolean? n) + (null? n) + (string? n))] + [(var-expr id) (symbol? id)] + [(let-expr x e1 e2 ) (and (symbol? x) + (expr? e1) + (expr? e2))] + [(letrec-expr x e1 e2) (and (symbol? x) + (expr? e1) + (expr? e2))] + [(if-expr eb et ef) (and (expr? eb) + (expr? et) + (expr? ef))] + [(lambda-expr x e) (and (symbol? x) + (expr? e))] + [(app-expr ef ea) (and (expr? ef) + (expr? ea))] + [_ false])) + +;; Parsowanie (zacytowane wyrażenie -> składnia abstrakcyjna) +(define (parse q) + (cond + [(number? q) (const q)] + [(string? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (const null)] + [(and (symbol? q) + (not (keyword q))) + (var-expr q)] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'let) + (list? (second q)) + (= (length (second q)) 2) + (symbol? (first (second q)))) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'letrec) + (list? (second q)) + (= (length (second q)) 2) + (symbol? (first (second q)))) + (letrec-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) + (= (length q) 4) + (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) + (pair? q) + (eq? (first q) 'and)) + (desugar-and (map parse (cdr q)))] + [(and (list? q) + (pair? q) + (eq? (first q) 'or)) + (desugar-or (map parse (cdr q)))] + [(and (list? q) + (>= (length q) 2) + (eq? (first q) 'cond)) + (parse-cond (cdr q))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'lambda) + (list? (second q)) + (andmap symbol? (second q)) + (cons? (second q))) + (desugar-lambda (second q) (parse (third q)))] + [(and (list? q) + (>= (length q) 2)) + (desugar-app (parse (first q)) (map parse (cdr q)))] + [else (error "Unrecognized token:" q)])) + +(define (parse-cond qs) + (match qs + [(list (list 'else q)) + (parse q)] + + [(list (list q _)) + (error "Expected 'else' in last branch but found:" q)] + + [(cons (list qb qt) qs) + (if-expr (parse qb) (parse qt) (parse-cond qs))])) + +(define (desugar-and es) + (if (null? es) + (const true) + (if-expr (car es) (desugar-and (cdr es)) (const false)))) + +(define (desugar-or es) + (if (null? es) + (const false) + (if-expr (car es) (const true) (desugar-or (cdr es))))) + +(define (desugar-lambda xs e) + (if (null? xs) + e + (lambda-expr (car xs) (desugar-lambda (cdr xs) e)))) + +(define (desugar-app e es) + (if (null? es) + e + (desugar-app (app-expr e (car es)) (cdr es)))) + +;; Środowiska +(struct blackhole ()) +(struct environ (xs)) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (mcons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) + (error "Unknown identifier" x)] + [(eq? x (mcar (car xs))) + (let ((v (mcdr (car xs)))) + (if (blackhole? v) + (error "Jumped into blackhole at" x) + v))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) +(define (env-update! x v env) + (define (assoc-update xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (mcar (car xs))) + (set-mcdr! (car xs) v)] + [else (assoc-update (cdr xs))])) + (assoc-update (environ-xs env))) + +;; Domknięcia +(struct clo (arg body env)) + +;; Procedury wbudowane, gdzie +;; proc — Racketowa procedura którą należy uruchomić +;; args — lista dotychczas dostarczonych argumentów +;; pnum — liczba brakujących argumentów (> 0) +;; W ten sposób pozwalamy na częściową aplikację Racketowych procedur +;; — zauważmy że zawsze znamy pnum, bo w naszym języku arność +;; procedury jest ustalona z góry +(struct builtin (proc args pnum) #:transparent) + +;; Pomocnicze konstruktory procedur unarnych i binarnych +(define (builtin/1 p) + (builtin (lambda (x) (return (p x))) null 1)) +(define (builtin/2 p) + (builtin (lambda (x y) (return (p x y))) null 2)) + +;; Procedury +(define (proc? v) + (or (and (clo? v) + (symbol? (clo-arg v)) + (expr? (clo-body v)) + (environ? (clo-env v))) + (and (builtin? v) + (procedure? (builtin-proc v)) + (andmap value? (builtin-args v)) + (natural? (builtin-pnum v)) + (> (builtin-pnum v) 0)))) + +;; Definicja typu wartości +(define (value? v) + (or (number? v) + (boolean? v) + (null? v) + (string? v) + (and (cons? v) + (value? (car v)) + (value? (cdr v))) + (proc? v))) + +;; Środowisko początkowe (przypisujące procedury wbudowane ich nazwom) + +(define start-env + (foldl (lambda (p env) (env-add (first p) (second p) env)) + env-empty + `((+ ,(builtin/2 +)) + (- ,(builtin/2 -)) + (* ,(builtin/2 *)) + (/ ,(builtin/2 /)) + (~ ,(builtin/1 -)) + (< ,(builtin/2 <)) + (> ,(builtin/2 >)) + (= ,(builtin/2 =)) + (<= ,(builtin/2 <=)) + (>= ,(builtin/2 >=)) + (not ,(builtin/1 not)) + (cons ,(builtin/2 cons)) + (car ,(builtin/1 car)) + (cdr ,(builtin/1 cdr)) + (pair? ,(builtin/1 cons?)) + (null? ,(builtin/1 null?)) + (boolean? ,(builtin/1 boolean?)) + (number? ,(builtin/1 number?)) + (procedure? ,(builtin/1 (lambda (x) (or (clo? x) (builtin? x))))) + (string? ,(builtin/1 string?)) + (string-= ,(builtin/2 string=?)) + ;; and so on, and so on + ))) + +;; Efekt + +(define (effect-builtin/1 p) + (builtin p null 1)) +(define (effect-builtin/2 p) + (builtin p null 2)) +(define (effect-builtin/3 p) + (builtin p null 3)) + + +(define effect-env + (foldl (lambda (p env) (env-add (first p) (second p) env)) + start-env + `((flip ,(effect-builtin/3 (lambda (p x y) (list (cons p x) (cons (- 1 p) y))))) + (uniform ,(effect-builtin/1 (lambda (x) (let ((l (/ 1 (length x)))) + (map (lambda (x) (cons l x)) x))))) + ))) + +;; c to lista par (pstwo, wartość) +;; k to funkcja która przyjmuje wartość i coś z nią robi sobie i zwraca listę par (pstwo, wartość) + +(define (bind c k) + (append-map + (lambda (x) (let ((pstwo (car x)) + (val (cdr x))) + (map + (lambda (x) (cons (* pstwo (car x)) (cdr x))) + (k (cdr x))))) + c)) + +(define (return x) (list (cons 1 x))) + +;; Ewaluator +(define (eval-env e env) + (match e + [(const n) + (return n)] + + [(var-expr x) + (return (env-lookup x env))] + + [(let-expr x e1 e2) + (bind (eval-env e1 env) (lambda (v1) + (eval-env e2 (env-add x v1 env))))] + + [(letrec-expr f ef eb) + (let ((new-env (env-add f (blackhole) env))) + (bind (eval-env ef new-env) (lambda (vf) + (env-update! f vf new-env) + (eval-env eb new-env))))] + + [(if-expr eb et ef) + (bind (eval-env eb env) (lambda (vb) + (match vb + [#t (eval-env et env)] + [#f (eval-env ef env)] + [v (error "Not a boolean:" v)])))] + + [(lambda-expr x e) + (return (clo x e env))] + + [(app-expr ef ea) + (bind (eval-env ef env) (lambda (vf) + (bind (eval-env ea env) (lambda (va) + (match vf + [(clo x e env) + (eval-env e (env-add x va env))] + [(builtin p args nm) + (if (= nm 1) + (apply p (reverse (cons va args))) + (return (builtin p (cons va args) (- nm 1))))] + [_ (error "Not a function:" vf)])))))])) + +(define (eval e) + (eval-env e effect-env)) + + +;; Przykladowy program + +(define PROGRAM + '((if (choose true false) (lambda (x) x) (lambda (x) (+ x 1))) (choose 1 2))) + + +;; REPL — interpreter interaktywny (read-eval-print loop) + +;; dodajemy składnię na wiązanie zmiennych "na poziomie interpretera" +;; i komendę wyjścia "exit" ... +(struct letrec-repl (id expr)) +(struct let-repl (id expr)) +(struct exit-repl ()) + +;; ... a także rozszerzoną procedurę parsującą te dodatkowe komendy i +;; prostą obsługę błędów +(define (parse-repl q) + (with-handlers + ([exn? (lambda (exn) + (display "Parse error! ") + (displayln (exn-message exn)))]) + (cond + [(eq? q 'exit) (exit-repl)] + [(and (list? q) + (= 3 (length q)) + (eq? (first q) 'let)) + (let-repl (second q) (parse (third q)))] + [(and (list? q) + (= 3 (length q)) + (eq? (first q) 'letrec)) + (letrec-repl (second q) (parse (third q)))] + [else (parse q)]))) + +;; trochę zamieszania w procedurze eval-repl wynika z rudymentarnej +;; obsługi błędów: nie chcemy żeby błąd w interpretowanym programie +;; kończył działanie całego interpretera! +(define (eval-repl c env continue) + (define (eval-with-err e env) + (with-handlers + ([exn? (lambda (exn) + (display "Error! ") + (displayln (exn-message exn)))]) + (eval-env e env))) + (match c + [(exit-repl) + (void)] + + [(let-repl x e) + (let ((v (eval-with-err e env))) + (if (void? v) + (continue env) + (continue (env-add x v env))))] + + [(letrec-repl f e) + (let* ((new-env (env-add f (blackhole) env)) + (v (eval-with-err e new-env))) + (if (void? v) + (continue env) + (begin + (env-update! f v new-env) + (continue new-env))))] + + [_ + (let ((v (eval-with-err c env))) + (unless (void? v) + (displayln v)) + (continue env))])) + +;; I w końcu interaktywny interpreter +(define (repl) + (define (go env) + (display "FUN > ") + (let* ((q (read)) + (c (parse-repl q))) + (if (void? c) + (go env) + (eval-repl c env go)))) + (displayln "Welcome to the FUN functional language interpreter!") + (go start-env)) + + +(define prog '(if (flip 0.3 true false) "wygrana" "przegrana")) + + +(define (norm xs) + (define sum (lambda (xs) (foldl + 0 xs))) + (define carlist (lambda (xs) (map car xs))) + (define (iter xs res) + (cond + [(null? xs) res] + [(member (cdar xs) (map cdr res)) (iter (cdr xs) res)] + [else (let* ((cur (cdar xs)) + (pstwa (filter (lambda (x) (equal? (cdr x) cur)) xs))) + (iter (cdr xs) (cons (cons (sum (carlist pstwa)) cur) res)))])) + (iter xs null)) + + +(define DICE-MANY + '(letrec [from-to (lambda (x n) + (cons x + (if (= x n) + null + (from-to (+ 1 x) n))))] + (let [dice (lambda (x) (uniform (from-to 1 6)))] + (letrec [dice-many (lambda (n) (if (= n 0) + 0 + (+ (dice 0) (dice-many (- n 1)))))] + (dice-many (dice 0)))))) \ No newline at end of file diff --git a/semestr-2/racket/l11/rozw.bak b/semestr-2/racket/l11/rozw.bak new file mode 100644 index 0000000..cda82ce --- /dev/null +++ b/semestr-2/racket/l11/rozw.bak @@ -0,0 +1,2 @@ +#lang racket + diff --git a/semestr-2/racket/l11/rozw.rkt b/semestr-2/racket/l11/rozw.rkt new file mode 100644 index 0000000..e45e403 --- /dev/null +++ b/semestr-2/racket/l11/rozw.rkt @@ -0,0 +1,776 @@ +#reader(lib"read.ss""wxme")WXME0109 ## +#| + This file uses the GRacket editor format. + Open this file in DrRacket version 7.6 or later to read it. + + Most likely, it was created by saving a program in DrRacket, + and it probably contains a program with non-text elements + (such as images or comment boxes). + + http://racket-lang.org/ +|# + 33 7 #"wxtext\0" +3 1 6 #"wxtab\0" +1 1 8 #"wximage\0" +2 0 8 #"wxmedia\0" +4 1 34 #"(lib \"syntax-browser.ss\" \"mrlib\")\0" +1 0 36 #"(lib \"cache-image-snip.ss\" \"mrlib\")\0" +1 0 68 +(0 + #"((lib \"image-core.ss\" \"mrlib\") (lib \"image-core-wxme.rkt\" \"mr" + #"lib\"))\0" +) 1 0 16 #"drscheme:number\0" +3 0 44 #"(lib \"number-snip.ss\" \"drscheme\" \"private\")\0" +1 0 36 #"(lib \"comment-snip.ss\" \"framework\")\0" +1 0 93 +(1 + #"((lib \"collapsed-snipclass.ss\" \"framework\") (lib \"collapsed-sni" + #"pclass-wxme.ss\" \"framework\"))\0" +) 0 0 43 #"(lib \"collapsed-snipclass.ss\" \"framework\")\0" +0 0 19 #"drscheme:sexp-snip\0" +0 0 29 #"drscheme:bindings-snipclass%\0" +1 0 101 +(2 + #"((lib \"ellipsis-snip.rkt\" \"drracket\" \"private\") (lib \"ellipsi" + #"s-snip-wxme.rkt\" \"drracket\" \"private\"))\0" +) 2 0 88 +(3 + #"((lib \"pict-snip.rkt\" \"drracket\" \"private\") (lib \"pict-snip.r" + #"kt\" \"drracket\" \"private\"))\0" +) 0 0 55 +#"((lib \"snip.rkt\" \"pict\") (lib \"snip-wxme.rkt\" \"pict\"))\0" +1 0 34 #"(lib \"bullet-snip.rkt\" \"browser\")\0" +0 0 25 #"(lib \"matrix.ss\" \"htdp\")\0" +1 0 22 #"drscheme:lambda-snip%\0" +1 0 29 #"drclickable-string-snipclass\0" +0 0 26 #"drracket:spacer-snipclass\0" +0 0 57 +#"(lib \"hrule-snip.rkt\" \"macro-debugger\" \"syntax-browser\")\0" +1 0 26 #"drscheme:pict-value-snip%\0" +0 0 45 #"(lib \"image-snipr.ss\" \"slideshow\" \"private\")\0" +1 0 38 #"(lib \"pict-snipclass.ss\" \"slideshow\")\0" +2 0 55 #"(lib \"vertical-separator-snip.ss\" \"stepper\" \"private\")\0" +1 0 18 #"drscheme:xml-snip\0" +1 0 31 #"(lib \"xml-snipclass.ss\" \"xml\")\0" +1 0 21 #"drscheme:scheme-snip\0" +2 0 34 #"(lib \"scheme-snipclass.ss\" \"xml\")\0" +1 0 10 #"text-box%\0" +1 0 32 #"(lib \"text-snipclass.ss\" \"xml\")\0" +1 0 1 6 #"wxloc\0" + 0 0 81 0 1 #"\0" +0 75 1 #"\0" +0 10 90 -1 90 -1 3 -1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 255 255 255 1 -1 0 9 +#"Standard\0" +0 75 12 #"Courier New\0" +0 16 90 -1 90 -1 3 -1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 255 255 255 1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 -1 -1 2 24 +#"framework:default-color\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 255 255 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 150 0 150 0 0 0 -1 -1 2 15 +#"text:ports out\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 34 119 34 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1.0 0 -1 -1 93 -1 -1 -1 0 0 0 0 0 0 0 0 0 1.0 1.0 1.0 255 0 0 0 0 0 -1 +-1 2 15 #"text:ports err\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 204 204 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 175 0 0 0 -1 -1 2 17 +#"text:ports value\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 144 179 255 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1.0 0 92 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1.0 1.0 1.0 34 139 34 0 0 0 -1 +-1 2 27 #"Matching Parenthesis Style\0" +0 -1 1 #"\0" +1.0 0 92 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1.0 1.0 1.0 34 139 34 0 0 0 -1 +-1 2 1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 38 38 128 0 0 0 -1 -1 2 37 +#"framework:syntax-color:scheme:symbol\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 144 179 255 0 0 0 -1 -1 2 +38 #"framework:syntax-color:scheme:keyword\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 144 179 255 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 194 116 31 0 0 0 -1 -1 2 +38 #"framework:syntax-color:scheme:comment\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 204 221 170 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 41 128 38 0 0 0 -1 -1 2 37 +#"framework:syntax-color:scheme:string\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 144 179 255 0 0 0 -1 -1 2 +35 #"framework:syntax-color:scheme:text\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 144 179 255 0 0 0 -1 -1 2 +39 #"framework:syntax-color:scheme:constant\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 144 179 255 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 132 60 36 0 0 0 -1 -1 2 49 +#"framework:syntax-color:scheme:hash-colon-keyword\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 144 179 255 0 0 0 -1 -1 2 +42 #"framework:syntax-color:scheme:parenthesis\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 0 178 178 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 255 0 0 0 0 0 -1 -1 2 36 +#"framework:syntax-color:scheme:error\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 204 204 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 -1 -1 2 36 +#"framework:syntax-color:scheme:other\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 144 179 255 0 0 0 -1 -1 2 +16 #"Misspelled Text\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 255 255 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 81 112 203 0 0 0 -1 -1 2 +38 #"drracket:check-syntax:lexically-bound\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 50 163 255 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 178 34 34 0 0 0 -1 -1 2 28 +#"drracket:check-syntax:set!d\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 204 204 0 0 0 -1 -1 2 +37 #"drracket:check-syntax:unused-require\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 204 204 0 0 0 -1 -1 2 +36 #"drracket:check-syntax:free-variable\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 204 204 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 68 0 203 0 0 0 -1 -1 2 31 +#"drracket:check-syntax:imported\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 166 0 255 0 0 0 -1 -1 2 47 +#"drracket:check-syntax:my-obligation-style-pref\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 255 192 203 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 0 116 0 0 0 0 -1 -1 2 50 +#"drracket:check-syntax:their-obligation-style-pref\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 50 205 50 0 0 0 -1 -1 2 48 +#"drracket:check-syntax:unk-obligation-style-pref\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 255 255 255 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 139 142 28 0 0 0 -1 -1 2 +49 #"drracket:check-syntax:both-obligation-style-pref\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 240 230 140 0 0 0 -1 -1 2 +26 #"plt:htdp:test-coverage-on\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 255 255 255 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 1 0 0 0 0 0 0 255 165 0 0 0 0 -1 -1 2 27 +#"plt:htdp:test-coverage-off\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 1 0 0 0 0 0 0 205 92 92 0 0 0 -1 -1 4 1 +#"\0" +0 70 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 1.0 1.0 1.0 1.0 1.0 1.0 0 0 0 0 0 0 +-1 -1 4 4 #"XML\0" +0 70 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 1.0 1.0 1.0 1.0 1.0 1.0 0 0 0 0 0 0 +-1 -1 2 37 #"plt:module-language:test-coverage-on\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 255 255 255 0 0 0 -1 -1 2 +38 #"plt:module-language:test-coverage-off\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 1 0 0 0 0 0 0 205 92 92 0 0 0 -1 -1 0 36 +#"mrlib/syntax-browser:subtitle-color\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 1 0 0 0 0 0 0 100 149 237 0 0 0 -1 -1 0 +42 #"mrlib/syntax-browser:focused-syntax-color\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 1 0 0 0 0 0 0 50 205 50 0 0 0 -1 -1 4 1 +#"\0" +0 71 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 1.0 1.0 1.0 1.0 1.0 1.0 0 0 0 0 0 0 +-1 -1 4 1 #"\0" +0 -1 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 1 0 0 0 0 0 0 0 0 1.0 1.0 1.0 0 191 255 0 0 0 -1 +-1 4 1 #"\0" +0 71 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 1 0 0 0 0 0 0 0 0 1.0 1.0 1.0 0 191 255 0 0 0 -1 +-1 4 1 #"\0" +0 71 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1.0 1.0 1.0 152 251 152 0 0 0 +-1 -1 4 32 #"widget.rkt::browser-text% basic\0" +0 70 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 1.0 1.0 1.0 1.0 1.0 1.0 0 0 0 0 0 0 +-1 -1 4 59 +#"macro-debugger/syntax-browser/properties color-text% basic\0" +0 70 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 1.0 1.0 1.0 1.0 1.0 1.0 0 0 0 0 0 0 +-1 -1 58 1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 190 190 190 0 0 0 -1 -1 2 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 200 0 0 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 255 255 0 0 0 -1 -1 4 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 0 0 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 255 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 185 220 113 0 0 0 -1 -1 4 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 155 255 155 0 0 0 -1 -1 4 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 116 116 0 0 0 -1 -1 4 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 18 67 155 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 30 70 190 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 75 135 185 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 176 208 208 0 0 0 -1 -1 4 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 116 116 255 0 0 0 -1 -1 4 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 200 125 255 0 0 0 -1 -1 4 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 143 15 223 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 165 0 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 141 19 5 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 244 194 71 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 255 255 127 0 0 0 -1 -1 4 +1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 86 86 86 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 1 0 0 0 0 0 0 255 255 255 0 31 31 -1 -1 +4 1 #"\0" +0 -1 1 #"\0" +1.0 0 92 -1 -1 -1 -1 -1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 255 255 0 -1 -1 + 0 475 0 28 3 12 #"#lang racket" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 3 1 #"(" +0 0 15 3 7 #"require" +0 0 24 3 1 #" " +0 0 14 3 15 #"racket/contract" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 17 3 13 #";;; Zadanie 1" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 3 1 #"(" +0 0 15 3 15 #"define/contract" +0 0 24 3 2 #" (" +0 0 14 3 8 #"suffixes" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 14 #"parametric->/c" +0 0 24 3 2 #" [" +0 0 14 3 1 #"a" +0 0 24 3 3 #"] (" +0 0 14 3 2 #"->" +0 0 24 3 2 #" (" +0 0 14 3 6 #"listof" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 3 #") (" +0 0 14 3 6 #"listof" +0 0 24 3 2 #" (" +0 0 14 3 6 #"listof" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 5 #")))) " +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 2 #"if" +0 0 24 3 2 #" (" +0 0 14 3 5 #"null?" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 6 #" " +0 0 14 3 4 #"null" +0 0 24 29 1 #"\n" +0 0 24 3 7 #" (" +0 0 14 3 4 #"cons" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 2 #" (" +0 0 14 3 8 #"suffixes" +0 0 24 3 2 #" (" +0 0 14 3 3 #"cdr" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 5 #")))))" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 17 3 13 #";;; Zadanie 2" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 3 1 #"(" +0 0 15 3 15 #"define/contract" +0 0 24 3 2 #" (" +0 0 14 3 8 #"sublists" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 14 #"parametric->/c" +0 0 24 3 2 #" [" +0 0 14 3 1 #"a" +0 0 24 3 3 #"] (" +0 0 14 3 2 #"->" +0 0 24 3 2 #" (" +0 0 14 3 6 #"listof" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 3 #") (" +0 0 14 3 6 #"listof" +0 0 24 3 2 #" (" +0 0 14 3 6 #"listof" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 6 #")))) " +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 2 #"if" +0 0 24 3 2 #" (" +0 0 14 3 5 #"null?" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 7 #" (" +0 0 14 3 4 #"list" +0 0 24 3 1 #" " +0 0 14 3 4 #"null" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 7 #" (" +0 0 14 3 10 #"append-map" +0 0 24 29 1 #"\n" +0 0 24 3 8 #" (" +0 0 15 3 6 #"lambda" +0 0 24 3 2 #" (" +0 0 14 3 2 #"ys" +0 0 24 3 3 #") (" +0 0 14 3 4 #"list" +0 0 24 3 2 #" (" +0 0 14 3 4 #"cons" +0 0 24 3 2 #" (" +0 0 14 3 3 #"car" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 2 #") " +0 0 14 3 2 #"ys" +0 0 24 3 2 #") " +0 0 14 3 2 #"ys" +0 0 24 3 2 #"))" +0 0 24 29 1 #"\n" +0 0 24 3 8 #" (" +0 0 14 3 8 #"sublists" +0 0 24 3 2 #" (" +0 0 14 3 3 #"cdr" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 5 #")))))" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 17 3 13 #";;; Zadanie 3" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 3 1 #"(" +0 0 15 3 15 #"define/contract" +0 0 24 3 2 #" (" +0 0 14 3 17 #"autistic-identity" +0 0 24 3 1 #" " +0 0 14 3 1 #"x" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 14 #"parametric->/c" +0 0 24 3 2 #" [" +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"b" +0 0 24 3 3 #"] (" +0 0 14 3 2 #"->" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"b" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 2 #"))" +0 0 24 29 1 #"\n" +0 0 24 3 2 #" " +0 0 14 3 1 #"x" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 3 1 #"(" +0 0 15 3 15 #"define/contract" +0 0 24 3 2 #" (" +0 0 14 3 6 #"create" +0 0 24 3 1 #" " +0 0 14 3 4 #"comb" +0 0 24 3 1 #" " +0 0 14 3 4 #"next" +0 0 24 3 1 #" " +0 0 14 3 3 #"beg" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 14 #"parametric->/c" +0 0 24 3 2 #" [" +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"b" +0 0 24 3 1 #" " +0 0 14 3 1 #"c" +0 0 24 3 3 #"] (" +0 0 14 3 2 #"->" +0 0 24 3 2 #" (" +0 0 14 3 2 #"->" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"b" +0 0 24 3 1 #" " +0 0 14 3 1 #"c" +0 0 24 3 3 #") (" +0 0 14 3 2 #"->" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"b" +0 0 24 3 2 #") " +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"c" +0 0 24 3 2 #"))" +0 0 24 29 1 #"\n" +0 0 24 3 4 #" ((" +0 0 14 3 4 #"comb" +0 0 24 3 2 #" (" +0 0 14 3 4 #"next" +0 0 24 3 1 #" " +0 0 14 3 3 #"beg" +0 0 24 3 2 #") " +0 0 14 3 3 #"beg" +0 0 24 3 3 #")))" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 3 1 #"(" +0 0 15 3 15 #"define/contract" +0 0 24 3 2 #" (" +0 0 14 3 7 #"compose" +0 0 24 3 1 #" " +0 0 14 3 2 #"bc" +0 0 24 3 1 #" " +0 0 14 3 2 #"ab" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 14 #"parametric->/c" +0 0 24 3 2 #" [" +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"b" +0 0 24 3 1 #" " +0 0 14 3 1 #"c" +0 0 24 3 3 #"] (" +0 0 14 3 2 #"->" +0 0 24 3 2 #" (" +0 0 14 3 2 #"->" +0 0 24 3 1 #" " +0 0 14 3 1 #"b" +0 0 24 3 1 #" " +0 0 14 3 1 #"c" +0 0 24 3 3 #") (" +0 0 14 3 2 #"->" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"b" +0 0 24 3 3 #") (" +0 0 14 3 2 #"->" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"c" +0 0 24 3 3 #")))" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 15 3 6 #"lambda" +0 0 24 3 2 #" (" +0 0 14 3 1 #"x" +0 0 24 3 3 #") (" +0 0 14 3 2 #"bc" +0 0 24 3 2 #" (" +0 0 14 3 2 #"ab" +0 0 24 3 1 #" " +0 0 14 3 1 #"x" +0 0 24 3 4 #"))))" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 3 1 #"(" +0 0 15 3 15 #"define/contract" +0 0 24 3 2 #" (" +0 0 14 3 5 #"ident" +0 0 24 3 1 #" " +0 0 14 3 1 #"f" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 14 #"parametric->/c" +0 0 24 3 2 #" [" +0 0 14 3 1 #"a" +0 0 24 3 3 #"] (" +0 0 14 3 2 #"->" +0 0 24 3 2 #" (" +0 0 14 3 2 #"->" +0 0 24 3 2 #" (" +0 0 14 3 2 #"->" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 2 #") " +0 0 14 3 1 #"a" +0 0 24 3 2 #") " +0 0 14 3 1 #"a" +0 0 24 3 2 #"))" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 1 #"f" +0 0 24 3 1 #" " +0 0 14 3 8 #"identity" +0 0 24 3 2 #"))" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 17 3 13 #";;; Zadanie 4" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 3 1 #"(" +0 0 15 3 15 #"define/contract" +0 0 24 3 2 #" (" +0 0 14 3 12 #"broken-contr" +0 0 24 3 1 #" " +0 0 14 3 1 #"x" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 14 #"parametric->/c" +0 0 24 3 2 #" [" +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"b" +0 0 24 3 3 #"] (" +0 0 14 3 2 #"->" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 1 #"b" +0 0 24 3 2 #"))" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 12 #"broken-contr" +0 0 24 3 1 #" " +0 0 14 3 1 #"x" +0 0 24 3 2 #"))" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 17 3 13 #";;; Zadanie 5" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 3 1 #"(" +0 0 15 3 15 #"define/contract" +0 0 24 3 2 #" (" +0 0 14 3 9 #"foldl-map" +0 0 24 3 1 #" " +0 0 14 3 1 #"f" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 14 #"parametric->/c" +0 0 24 3 2 #" [" +0 0 14 3 1 #"F" +0 0 24 3 1 #" " +0 0 14 3 1 #"A" +0 0 24 3 1 #" " +0 0 14 3 1 #"L" +0 0 24 3 3 #"] (" +0 0 14 3 2 #"->" +0 0 24 3 2 #" (" +0 0 14 3 2 #"->" +0 0 24 3 1 #" " +0 0 14 3 1 #"L" +0 0 24 3 1 #" " +0 0 14 3 1 #"A" +0 0 24 3 2 #" (" +0 0 14 3 6 #"cons/c" +0 0 24 3 1 #" " +0 0 14 3 1 #"F" +0 0 24 3 1 #" " +0 0 14 3 1 #"A" +0 0 24 3 3 #")) " +0 0 14 3 1 #"A" +0 0 24 3 2 #" (" +0 0 14 3 6 #"listof" +0 0 24 3 1 #" " +0 0 14 3 1 #"L" +0 0 24 3 3 #") (" +0 0 14 3 6 #"cons/c" +0 0 24 3 2 #" (" +0 0 14 3 6 #"listof" +0 0 24 3 1 #" " +0 0 14 3 1 #"F" +0 0 24 3 2 #") " +0 0 14 3 1 #"A" +0 0 24 3 4 #"))) " +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 15 3 6 #"define" +0 0 24 3 2 #" (" +0 0 14 3 2 #"it" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 1 #" " +0 0 14 3 2 #"ys" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 5 #" (" +0 0 14 3 2 #"if" +0 0 24 3 2 #" (" +0 0 14 3 5 #"null?" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 9 #" (" +0 0 14 3 4 #"cons" +0 0 24 3 2 #" (" +0 0 14 3 7 #"reverse" +0 0 24 3 1 #" " +0 0 14 3 2 #"ys" +0 0 24 3 2 #") " +0 0 14 3 1 #"a" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 9 #" (" +0 0 15 3 3 #"let" +0 0 24 3 3 #" [(" +0 0 14 3 1 #"p" +0 0 24 3 2 #" (" +0 0 14 3 1 #"f" +0 0 24 3 2 #" (" +0 0 14 3 3 #"car" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 2 #") " +0 0 14 3 1 #"a" +0 0 24 3 3 #"))]" +0 0 24 29 1 #"\n" +0 0 24 3 11 #" (" +0 0 14 3 2 #"it" +0 0 24 3 2 #" (" +0 0 14 3 3 #"cdr" +0 0 24 3 1 #" " +0 0 14 3 1 #"p" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 15 #" (" +0 0 14 3 3 #"cdr" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 15 #" (" +0 0 14 3 4 #"cons" +0 0 24 3 2 #" (" +0 0 14 3 3 #"car" +0 0 24 3 1 #" " +0 0 14 3 1 #"p" +0 0 24 3 2 #") " +0 0 14 3 2 #"ys" +0 0 24 3 5 #")))))" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 2 #"it" +0 0 24 3 1 #" " +0 0 14 3 1 #"a" +0 0 24 3 1 #" " +0 0 14 3 2 #"xs" +0 0 24 3 1 #" " +0 0 14 3 4 #"null" +0 0 24 3 2 #"))" +0 0 diff --git a/semestr-2/racket/l11/solution.bak b/semestr-2/racket/l11/solution.bak new file mode 100644 index 0000000..3ae167a --- /dev/null +++ b/semestr-2/racket/l11/solution.bak @@ -0,0 +1,18 @@ +#lang racket + +(require racket/contract) + +(provide (contract-out [square square/c])) +(provide square/c) + +(define square/c (-> number? (not/c negative?))) + +(define (square x) (* x x)) + + +(define with-labels/c (parametric->/c [a b] (-> (-> a b)) + +(define (with-labels f xs) + (if (null? xs) + null + (cons (list (f (car xs)) (car xs)) (with-labels f (cdr xs))))) \ No newline at end of file diff --git a/semestr-2/racket/l11/solution.rkt b/semestr-2/racket/l11/solution.rkt new file mode 100644 index 0000000..55e4ba6 --- /dev/null +++ b/semestr-2/racket/l11/solution.rkt @@ -0,0 +1,35 @@ +#lang racket + +(provide (contract-out + [with-labels with-labels/c] + [foldr-map foldr-map/c] + [pair-from pair-from/c])) +(provide with-labels/c foldr-map/c pair-from/c) + + +(define with-labels/c (parametric->/c [a b] (-> (-> a b) (listof a) (listof (cons/c b (cons/c a null?)))))) + +(define (with-labels f xs) + (if (null? xs) + null + (cons (list (f (car xs)) (car xs)) (with-labels f (cdr xs))))) + + + +(define foldr-map/c (parametric->/c [x a f] (-> (-> x a (cons/c f a)) a (listof x) (cons/c (listof f) a)))) + +(define (foldr-map f a xs) + (define (it a xs ys) + (if (null? xs) + (cons ys a) + (let [(p (f (car xs) a))] + (it (cdr p) + (cdr xs) + (cons (car p) ys))))) + (it a (reverse xs) null)) + + +(define pair-from/c (parametric->/c [x fx gx] (-> (-> x fx) (-> x gx) (-> x (cons/c fx gx))))) + +(define (pair-from f g) + (lambda (x) (cons (f x) (g x)))) \ No newline at end of file diff --git a/semestr-2/racket/l11z20/compiled/drracket/errortrace/graph_rkt.dep b/semestr-2/racket/l11z20/compiled/drracket/errortrace/graph_rkt.dep new file mode 100644 index 0000000..6d38ce0 --- /dev/null +++ b/semestr-2/racket/l11z20/compiled/drracket/errortrace/graph_rkt.dep @@ -0,0 +1 @@ +("7.6" racket ("b51d3a36a64d34c7978bfc22f2a5fe674cee1cb6" . "8314027ed4c1c6fd9c412af77103e94790e59dd2") (collects #"errortrace" #"errortrace-key.rkt") (collects #"racket" #"main.rkt") (collects #"racket" #"runtime-config.rkt")) diff --git a/semestr-2/racket/l11z20/compiled/drracket/errortrace/graph_rkt.zo b/semestr-2/racket/l11z20/compiled/drracket/errortrace/graph_rkt.zo new file mode 100644 index 0000000..ef91f9a Binary files /dev/null and b/semestr-2/racket/l11z20/compiled/drracket/errortrace/graph_rkt.zo differ diff --git a/semestr-2/racket/l11z20/graph.bak b/semestr-2/racket/l11z20/graph.bak new file mode 100644 index 0000000..9f4d79d --- /dev/null +++ b/semestr-2/racket/l11z20/graph.bak @@ -0,0 +1,97 @@ +#lang racket + +(provide bag^ graph^ simple-graph@ graph-search^ graph-search@) + +;; sygnatura dla struktury danych +(define-signature bag^ + ((contracted + [bag? (-> any/c boolean?)] + [empty-bag (and/c bag? bag-empty?)] + [bag-empty? (-> bag? boolean?)] + [bag-insert (-> bag? any/c (and/c bag? (not/c bag-empty?)))] + [bag-peek (-> (and/c bag? (not/c bag-empty?)) any/c)] + [bag-remove (-> (and/c bag? (not/c bag-empty?)) bag?)]))) + +;; sygnatura: grafy +(define-signature graph^ + ((contracted + [graph (-> list? (listof edge?) graph?)] + [graph? (-> any/c boolean?)] + [graph-nodes (-> graph? list?)] + [graph-edges (-> graph? (listof edge?))] + [edge (-> any/c any/c edge?)] + [edge? (-> any/c boolean?)] + [edge-start (-> edge? any/c)] + [edge-end (-> edge? any/c)] + [has-node? (-> graph? any/c boolean?)] + [outnodes (-> graph? any/c list?)] + [remove-node (-> graph? any/c graph?)] + ))) + +;; prosta implementacja grafów +(define-unit simple-graph@ + (import) + (export graph^) + + (define (graph? g) + (and (list? g) + (eq? (length g) 3) + (eq? (car g) 'graph))) + + (define (edge? e) + (and (list? e) + (eq? (length e) 3) + (eq? (car e) 'edge))) + + (define (graph-nodes g) (cadr g)) + + (define (graph-edges g) (caddr g)) + + (define (graph n e) (list 'graph n e)) + + (define (edge n1 n2) (list 'edge n1 n2)) + + (define (edge-start e) (cadr e)) + + (define (edge-end e) (caddr e)) + + (define (has-node? g n) (not (not (member n (graph-nodes g))))) + + (define (outnodes g n) + (filter-map + (lambda (e) + (and (eq? (edge-start e) n) + (edge-end e))) + (graph-edges g))) + + (define (remove-node g n) + (graph + (remove n (graph-nodes g)) + (filter + (lambda (e) + (not (eq? (edge-start e) n))) + (graph-edges g))))) + +;; sygnatura dla przeszukiwania grafu +(define-signature graph-search^ + (search)) + +;; implementacja przeszukiwania grafu +;; uzależniona od implementacji grafu i struktury danych +(define-unit graph-search@ + (import bag^ graph^) + (export graph-search^) + (define (search g n) + (define (it g b l) + (cond + [(bag-empty? b) (reverse l)] + [(has-node? g (bag-peek b)) + (it (remove-node g (bag-peek b)) + (foldl + (lambda (n1 b1) (bag-insert b1 n1)) + (bag-remove b) + (outnodes g (bag-peek b))) + (cons (bag-peek b) l))] + [else (it g (bag-remove b) l)])) + (it g (bag-insert empty-bag n) '())) + ) diff --git a/semestr-2/racket/l11z20/graph.rkt b/semestr-2/racket/l11z20/graph.rkt new file mode 100644 index 0000000..ec19576 --- /dev/null +++ b/semestr-2/racket/l11z20/graph.rkt @@ -0,0 +1,100 @@ +#lang racket + +(provide bag^ graph^ simple-graph@ graph-search^ graph-search@) + +;; sygnatura dla struktury danych +(define-signature bag^ + ((contracted + [bag? (-> any/c boolean?)] + [empty-bag (and/c bag? bag-empty?)] + [bag-empty? (-> bag? boolean?)] + [bag-insert (-> bag? any/c (and/c bag? (not/c bag-empty?)))] + [bag-peek (-> (and/c bag? (not/c bag-empty?)) any/c)] + [bag-remove (-> (and/c bag? (not/c bag-empty?)) bag?)]))) + +;; sygnatura: grafy +(define-signature graph^ + ((contracted + [graph (-> list? (listof edge?) graph?)] + [graph? (-> any/c boolean?)] + [graph-nodes (-> graph? list?)] + [graph-edges (-> graph? (listof edge?))] + [edge (-> any/c any/c edge?)] + [edge? (-> any/c boolean?)] + [edge-start (-> edge? any/c)] + [edge-end (-> edge? any/c)] + [has-node? (-> graph? any/c boolean?)] + [outnodes (-> graph? any/c list?)] + [remove-node (-> graph? any/c graph?)] + ))) + +;; prosta implementacja grafów +(define-unit simple-graph@ + (import) + (export graph^) + + (define (graph? g) + (and (list? g) + (eq? (length g) 3) + (eq? (car g) 'graph))) + + (define (edge? e) + (and (list? e) + (eq? (length e) 3) + (eq? (car e) 'edge))) + + (define (graph-nodes g) (cadr g)) + + (define (graph-edges g) (caddr g)) + + (define (graph n e) (list 'graph n e)) + + (define (edge n1 n2) (list 'edge n1 n2)) + + (define (edge-start e) (cadr e)) + + (define (edge-end e) (caddr e)) + + (define (has-node? g n) (not (not (member n (graph-nodes g))))) + + (define (outnodes g n) + (filter-map + (lambda (e) + (and (eq? (edge-start e) n) + (edge-end e))) + (graph-edges g))) + + (define (remove-node g n) + (graph + (remove n (graph-nodes g)) + (filter + (lambda (e) + (not (eq? (edge-start e) n))) + (graph-edges g))))) + +;; sygnatura dla przeszukiwania grafu +(define-signature graph-search^ + (search)) + +;; implementacja przeszukiwania grafu +;; uzależniona od implementacji grafu i struktury danych +(define-unit graph-search@ + (import bag^ graph^) + (export graph-search^) + (define (search g n) + (define (it g b l) + (cond + [(bag-empty? b) (reverse l)] + [(has-node? g (bag-peek b)) + (it (remove-node g (bag-peek b)) + (foldl + (lambda (n1 b1) (bag-insert b1 n1)) + (bag-remove b) + (outnodes g (bag-peek b))) + (cons (bag-peek b) l))] + [else (it g (bag-remove b) l)])) + (it g (bag-insert empty-bag n) '())) + ) + +;; otwarcie komponentu grafu +(define-values/invoke-unit/infer simple-graph@) \ No newline at end of file diff --git a/semestr-2/racket/l11z20/solution.bak b/semestr-2/racket/l11z20/solution.bak new file mode 100644 index 0000000..6f1f7b4 --- /dev/null +++ b/semestr-2/racket/l11z20/solution.bak @@ -0,0 +1 @@ +#lang racket diff --git a/semestr-2/racket/l11z20/solution.rkt b/semestr-2/racket/l11z20/solution.rkt new file mode 100644 index 0000000..e3ad81f --- /dev/null +++ b/semestr-2/racket/l11z20/solution.rkt @@ -0,0 +1,245 @@ +#lang racket + +(require "graph.rkt") +(provide bag-stack@ bag-fifo@) + +;; struktura danych - stos +(define-unit bag-stack@ + (import) + (export bag^) + + (define (bag? b) + (and (cons? b) + (eq? (car b) 'stack))) + + (define empty-bag (cons 'stack null)) + + (define (bag-empty? b) + (null? (cdr b))) + + (define (bag-insert b val) + (cons 'stack (cons val (cdr b)))) + + (define (bag-peek b) + (cadr b)) + + (define (bag-remove b) + (cons 'stack (cddr b))) +) + +;; struktura danych - kolejka FIFO +(define-unit bag-fifo@ + (import) + (export bag^) + + (define (bag? b) + (and (list? b) + (eq? (length b) 3) + (eq? (first b) 'queue))) + + (define empty-bag + (list 'queue null null)) + + (define (bag-empty? b) + (and (null? (second b)) (null? (third b)))) + + (define (bag-insert b val) + (list 'queue (cons val (second b)) (third b))) + + (define (bag-peek b) + (let ((insq (second b)) + (popq (third b))) + (cond + [(null? popq) (last insq)] + [else (first popq)]))) + + (define (bag-remove b) + (let ((insq (second b)) + (popq (third b))) + (cond + [(null? popq) (list 'queue null (cdr (reverse insq)))] + [else (list 'queue insq (cdr popq))]))) +) + +;; otwarcie komponentów stosu i kolejki + +(define-values/invoke-unit bag-stack@ + (import) + (export (prefix stack: bag^))) + +(define-values/invoke-unit bag-fifo@ + (import) + (export (prefix fifo: bag^))) + +;; testy w Quickchecku +(require quickcheck) + +;; liczba zapytań na test quickchecka +(define TESTS 1000) + + +;; TESTY DO KOLEJKI + +;; xs to lista jakichś liczb, queries to rodzaj wykonywanych operacji +;; 0 - popuje na listę pops +;; 1 - insertuje na queue +;; jest nie ma nic na kolejce/stosie i dostajemy 0, to nic nie robimy +;; jesli queries albo xs są puste to po prostu kończymy obsługiwanie zapytań +;; na koncu sprawdzamy, czy (reverse pops) jest prefiksem xs + + +(define (check-queue xs queries) + (define (iter xs queries queue pops) + ;; (display queue) + ;; (newline) + (if (or (null? queries) (null? xs)) + (reverse pops) + (cond + [(and (eq? (car queries) 0) (not (fifo:bag-empty? queue))) + (iter xs (cdr queries) (fifo:bag-remove queue) (cons (fifo:bag-peek queue) pops))] + [else (iter (cdr xs) (cdr queries) (fifo:bag-insert queue (car xs)) pops)]))) + (define (is-prefix? xs ys) + (if (null? xs) + #t + (and (equal? (car xs) (car ys)) (is-prefix? (cdr xs) (cdr ys))))) + (is-prefix? (iter xs queries fifo:empty-bag null) xs)) + +;; sprawdzenie czy nasza funkcja testująca w ogóle działa +(define check-queue-test (lambda () (check-queue (list 1 2 3 4 5 6 7 8) (list 0 1 1 1 0 0 0 1 1 0 1 0 1 0 0)))) + +;; testowanie kolejki +(define-unit queue-tests@ + (import bag^) + (export) + + (quickcheck + (property ([xs (choose-list (choose-real -100000 100000) TESTS)] + [ops (choose-list (choose-integer 0 1) TESTS)]) + (check-queue xs ops)))) + +(invoke-unit queue-tests@ (import (prefix fifo: bag^))) + + +;; TESTY DO STOSU + +;; niestety tutaj nie jest tak kolorowo, na kolejce +;; dokładnie wiemy jaka jest koljeność popowanych, na stosie to dosyć dowolne. +;; Z drugiej strony jego implementacja jest dużo prostsza, więc testy też nie muszą +;; być bardzo rygorystyczne. + +(define (check-stack xs) + (define (insert-list stack xs) + (if (null? xs) + stack + (insert-list (stack:bag-insert stack (car xs)) (cdr xs)))) + (define (clear-stack stack pops) + (if (stack:bag-empty? stack) + pops + (clear-stack (stack:bag-remove stack) (cons (stack:bag-peek stack) pops)))) + (equal? xs (clear-stack (insert-list stack:empty-bag xs) null))) + + +;; testowanie stacka +(define-unit stack-tests@ + (import bag^) + (export) + (quickcheck + (property ([xs (choose-list (choose-real -100000 100000) TESTS)]) + (check-stack xs)))) + +(invoke-unit stack-tests@ (import (prefix stack: bag^))) + + + +;; testy kolejek i stosów +(define-unit bag-tests@ + (import bag^) + (export) + + ;; test przykładowy: jeśli do pustej struktury dodamy element + ;; i od razu go usuniemy, wynikowa struktura jest pusta + (quickcheck + (property ([s arbitrary-symbol]) + (bag-empty? (bag-remove (bag-insert empty-bag s))))) + + ;; Sprawdzenie własności wspólnych dla obu struktur + (quickcheck + (property ([s arbitrary-symbol]) + (equal? s (bag-peek (bag-insert empty-bag s))))) +) + +;; uruchomienie testów dla obu struktur danych + +(invoke-unit bag-tests@ (import (prefix stack: bag^))) +(invoke-unit bag-tests@ (import (prefix fifo: bag^))) + + + +;; TESTOWANIE PRZESZUKIWAŃ + +;; otwarcie komponentu grafu +(define-values/invoke-unit/infer simple-graph@) + +;; otwarcie komponentów przeszukiwania +;; w głąb i wszerz +(define-values/invoke-unit graph-search@ + (import graph^ (prefix stack: bag^)) + (export (prefix dfs: graph-search^))) + +(define-values/invoke-unit graph-search@ + (import graph^ (prefix fifo: bag^)) + (export (prefix bfs: graph-search^))) + +;; graf testowy +(define test-graph + (graph + (list 1 2 3 4) + (list (edge 1 3) + (edge 1 2) + (edge 2 4)))) + +(define test-graph2 + (graph (list 1) null)) + +(define test-graph3 + (graph (list 1 2 3 4 5 6 7 8 9 10) + (list (edge 1 2) + (edge 1 3) + (edge 2 3) + (edge 3 2) + (edge 3 5) + (edge 6 5) + (edge 5 7) + (edge 5 8) + (edge 7 9) + (edge 8 9) + (edge 9 10) + (edge 1 10) + (edge 10 1)))) + + +(define test-graph4 + (graph (list 1 2 3 4 5 6) + (list (edge 1 2) + (edge 2 3) + (edge 3 4) + (edge 4 5) + (edge 5 6)))) + +;; uruchomienie przeszukiwania na przykładowym grafie +(bfs:search test-graph 1) +(dfs:search test-graph 1) + +(bfs:search test-graph2 1) +(dfs:search test-graph2 1) + +(bfs:search test-graph3 1) +(dfs:search test-graph3 1) + +(bfs:search test-graph3 6) +(dfs:search test-graph3 6) + +(bfs:search test-graph4 1) +(dfs:search test-graph4 1) + + diff --git a/semestr-2/racket/l13/oceny.txt b/semestr-2/racket/l13/oceny.txt new file mode 100644 index 0000000..9f17cad --- /dev/null +++ b/semestr-2/racket/l13/oceny.txt @@ -0,0 +1,18 @@ +1 sem + +MDM - 5 5 +AO - 5 +AM 1 - 5 5 +LDI - 5 5 +MIA - 5 + +8 * 5 + + +2 sem + +Topologia - 5 3 +Analiza - 4 4 +MP - 5 5 +PPS - 5 +Algebra - 5 5 \ No newline at end of file diff --git a/semestr-2/racket/l13/rozw.rkt b/semestr-2/racket/l13/rozw.rkt new file mode 100644 index 0000000..b4094db --- /dev/null +++ b/semestr-2/racket/l13/rozw.rkt @@ -0,0 +1,79 @@ +#lang typed/racket + + +;;; zadanie 1 + +(: prefixes (All (a) (-> (Listof a) (Listof (Listof a))))) +(define (prefixes xs) + (if (null? xs) + (list null) + (cons xs (prefixes (cdr xs))))) + + + +;;; zadanie 2 + +(struct vector2 ([x : Real] [y : Real]) #:transparent) +(struct vector3 ([x : Real] [y : Real] [z : Real]) #:transparent) + +(define-type Vector (U vector2 vector3)) +(define-predicate vector? Vector) + + +(: square (-> Real Nonnegative-Real)) +(define (square x) + (if (< x 0) (* x x) (* x x))) + + +;;; pierwsza wersja + +(: vector-length (-> Vector Nonnegative-Real)) +(define (vector-length v) + (if (vector2? v) + (match v [(vector2 x y) (sqrt (+ (square x) (square y)))]) + (match v [(vector3 x y z) (sqrt (+ (square x) (square y) (square z)))]))) + + +;;; druga wersja + +(: vector-length-match (-> Vector Nonnegative-Real)) +(define (vector-length-match v) + (match v + [(vector2 x y) (sqrt (+ (square x) (square y)))] + [(vector3 x y z) (sqrt (+ (square x) (square y) (square z)))])) + + + +;;; zadanie 4 + +(struct leaf () #:transparent) +(struct [a] node ([v : a] [xs : (Listof (Tree a))]) #:transparent) + +(define-type (Tree a) (node a)) +(define-predicate tree? (Tree Any)) + + +(: flat-map (All (a) (-> (-> (Tree a) (Listof a)) (Listof (Tree a)) (Listof a)))) +(define (flat-map f xs) + (if (null? xs) + null + (append (f (car xs)) (flat-map f (cdr xs))))) + +(: preorder (All (a) (-> (Tree a) (Listof a)))) +(define (preorder t) + (match t + [(node v xs) + (cons v (flat-map preorder xs))])) + +;;; (preorder (node 1 (list +;;; (node 2 (list +;;; (node 3 '()) +;;; (node 4 '()))) +;;; (node 5 '()) +;;; (node 'x (list +;;; (node 't (list +;;; (node 'z '())))))))) + + +;;; zadanie 6 + diff --git a/semestr-2/racket/l13/solution.rkt b/semestr-2/racket/l13/solution.rkt new file mode 100644 index 0000000..61804b3 --- /dev/null +++ b/semestr-2/racket/l13/solution.rkt @@ -0,0 +1,124 @@ +#lang typed/racket + +; --------- ; +; Wyrazenia ; +; --------- ; + +(provide parse typecheck) + +(define-type Expr (U const binop var-expr let-expr if-expr)) +(define-type Value (U Real Boolean)) +(define-type ArithOp (U '+ '- '/ '* '%)) +;;; (define-type ModOp '%) +(define-type CompOp (U '= '> '>= '< '<=)) +(define-type LogicOp (U 'and 'or)) +(define-type BinopSym (U ArithOp CompOp LogicOp)) + +(struct const ([val : Value]) #:transparent) +(struct binop ([op : BinopSym] [l : Expr] [r : Expr]) #:transparent) +(struct var-expr ([id : Symbol]) #:transparent) +(struct let-expr ([id : Symbol] [e1 : Expr] [e2 : Expr]) #:transparent) +(struct if-expr ([eb : Expr] [et : Expr] [ef : Expr]) #:transparent) + +(define-predicate expr? Expr) +(define-predicate value? Value) +(define-predicate arith-op? ArithOp) +;;; (define-predicate mod-op? ModOp) +(define-predicate comp-op? CompOp) +(define-predicate logic-op? LogicOp) +(define-predicate binop-sym? BinopSym) +(define-predicate let-list? (List Symbol Any)) + +(: parse (-> Any Expr)) +(define (parse q) + (match q + [_ #:when (value? q) (const q)] + [_ #:when (eq? q 'true) (const true)] + [_ #:when (eq? q 'false) (const false)] ; <---------------------------- !!! + [_ #:when (symbol? q) (var-expr q)] + [`(,s ,e1 ,e2) + #:when (and (eq? s 'let) (let-list? e1)) + (let-expr (car e1) + (parse (cadr e1)) + (parse e2))] + [`(,s ,eb ,et ,ef) + #:when (eq? s 'if) + (if-expr (parse eb) + (parse et) + (parse ef))] + [`(,s ,e1 ,e2) + #:when (binop-sym? s) + (binop s + (parse e1) + (parse e2))] + [else (error "Parse error" q)])) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(define-type EType (U 'real 'boolean)) +(define-predicate EType? EType) + +(struct environ ([xs : (Listof (Pairof Symbol EType))])) +(define env-empty (environ null)) + +(: env-add (-> Symbol EType environ environ)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) + +(: env-lookup (-> Symbol environ EType)) +(define (env-lookup x env) + (: assoc-lookup (-> (Listof (Pairof Symbol EType)) EType)) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +(: check-op (-> Expr Expr EType EType environ (U EType #f))) +(define (check-op e1 e2 arg-type ret-type env) + (if (and (eq? (typecheck-env e1 env) arg-type) + (eq? (typecheck-env e2 env) arg-type)) + ret-type + #f)) + +(: typecheck-env (-> Expr environ (U EType #f))) +(define (typecheck-env e env) + (match e + [(const val) + (cond + [(real? val) 'real] + [(boolean? val) 'boolean])] + [(var-expr id) (env-lookup id env)] + [(binop op e1 e2) + (cond + [(arith-op? op) (check-op e1 e2 'real 'real env)] + [(comp-op? op) (check-op e1 e2 'real 'boolean env)] + [(logic-op? op) (check-op e1 e2 'boolean 'boolean env)])] + [(let-expr id e1 e2) + (let ((id-type (typecheck-env e1 env))) + (if id-type + (typecheck-env e2 (env-add id id-type env)) + #f))] + [(if-expr eb et ef) + (let ((eb-type (typecheck-env eb env))) + (if (not (eq? eb-type 'boolean)) + #f + (let ((et-type (typecheck-env et env)) + (ef-type (typecheck-env ef env))) + (if (eq? et-type ef-type) ;;; nie trzeba sprawdzac czy ktores z nich to #f + et-type ;;; jesli tak jest, to i tak sie na pewno zwroci #f + #f))))])) + +(: typecheck (-> Expr (U EType #f))) +(define (typecheck e) + (typecheck-env e env-empty)) + +(define program + '(if (or (< (% 123 10) 5) + true) + (+ 2 3) + (/ 2 0))) + +(define (test-eval) (eval (parse program))) \ No newline at end of file diff --git a/semestr-2/racket/l13/zad6.rkt b/semestr-2/racket/l13/zad6.rkt new file mode 100644 index 0000000..1dcfbfc --- /dev/null +++ b/semestr-2/racket/l13/zad6.rkt @@ -0,0 +1,132 @@ +#lang typed/racket + +; Do let-env.rkt dodajemy wartosci boolowskie +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(define-type Expr (U const binop var-expr let-expr if-expr)) +(define-type Value (U Real Boolean)) +(define-type BinopSym (U '+ '- '/ '* '% '= '> '>= '< '<= 'and 'or)) + +(struct const ([val : Value]) #:transparent) +(struct binop ([op : BinopSym] [l : Expr] [r : Expr]) #:transparent) +(struct var-expr ([id : Symbol]) #:transparent) +(struct let-expr ([id : Symbol] [e1 : Expr] [e2 : Expr]) #:transparent) +(struct if-expr ([eb : Expr] [et : Expr] [ef : Expr]) #:transparent) + + +(define-predicate expr? Expr) +(define-predicate value? Value) +(define-predicate binop-sym? BinopSym) +(define-predicate let-list? (List Symbol Any)) + +(: parse (-> Any Expr)) +(define (parse q) + (match q + [_ #:when (value? q) (const q)] + [_ #:when (eq? q 'true) (const true)] + [_ #:when (eq? q 'false) (const false)] ; <---------------------------- !!! + [_ #:when (symbol? q) (var-expr q)] + [`(,s ,e1 ,e2) + #:when (and (eq? s 'let) (let-list? e1)) + (let-expr (car e1) + (parse (cadr e1)) + (parse e2))] + [`(,s ,eb ,et ,ef) + #:when (eq? s 'if) + (if-expr (parse eb) + (parse et) + (parse ef))] + [`(,s ,e1 ,e2) + #:when (binop-sym? s) + (binop s + (parse e1) + (parse e2))] + [else (error "Parse error" q)])) + +;;; (define (test-parse) (parse '(let [x (+ 2 2)] (+ x 1)))) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ ([xs : (Listof (Pairof Symbol Value))])) +(define env-empty (environ null)) + +(: env-add (-> Symbol Value environ environ)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) + +(: env-lookup (-> Symbol environ Value)) +(define (env-lookup x env) + (: assoc-lookup (-> (Listof (Pairof Symbol Value)) Value)) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(: arith-op (-> (-> Real Real Real) (-> Value Value Value))) +(define (arith-op op) + (lambda (x y) (if (and (real? x) (real? y)) + (ann (op x y) Value) + (error "Wrong args for arithmetic operator" op x y)))) + +(: mod-op (-> (-> Integer Integer Integer) (-> Value Value Value))) +(define (mod-op op) + (lambda (x y) (if (and (exact-integer? x) (exact-integer? y)) + (ann (op x y) Value) + (error "Wrong args for modulo operator" op x y)))) + +(: logic-op (-> (-> Boolean Boolean Boolean) (-> Value Value Value))) +(define (logic-op op) + (lambda (x y) (if (and (boolean? x) (boolean? y)) + (ann (op x y) Value) + (error "Wrong args for logic operator" op x y)))) + +(: comp-op (-> (-> Real Real Boolean) (-> Value Value Value))) +(define (comp-op op) + (lambda (x y) (if (and (real? x) (real? y)) + (ann (op x y) Value) + (error "Wrong args for comparator" op x y)))) + + +(: op->proc (-> BinopSym (-> Value Value Value))) +(define (op->proc op) + (match op ['+ (arith-op +)] ['- (arith-op -)] ['* (arith-op *)] ['/ (arith-op /)] + ['% (mod-op modulo)] + ['= (comp-op =)] ['> (comp-op >)] ['>= (comp-op >=)] ['< (comp-op <)] ['<= (comp-op <=)] + ['and (logic-op (lambda (x y) (and x y)))] + ['or (logic-op (lambda (x y) (or x y)))])) + +(: eval-env (-> Expr environ Value)) +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) ; <----------------- !!! + (eval-env et env) + (eval-env ef env))])) + +(: eval (-> Expr Value)) +(define (eval e) (eval-env e env-empty)) + +(define program + '(if (or (< (% 123 10) 5) + true) + (+ 2 3) + (/ 2 0))) + +;;; (define (test-eval) (eval (parse program))) \ No newline at end of file diff --git a/semestr-2/racket/l14z22/solution.bak b/semestr-2/racket/l14z22/solution.bak new file mode 100644 index 0000000..0d4f164 --- /dev/null +++ b/semestr-2/racket/l14z22/solution.bak @@ -0,0 +1,70 @@ +#lang racket + +(require racklog) + +(provide solve) + +;; transpozycja tablicy zakodowanej jako lista list +(define (transpose xss) + (cond [(null? xss) xss] + ((null? (car xss)) (transpose (cdr xss))) + [else (cons (map car xss) + (transpose (map cdr xss)))])) + +;; procedura pomocnicza +;; tworzy listę n-elementową zawierającą wyniki n-krotnego +;; wywołania procedury f +(define (repeat-fn n f) + (if (eq? 0 n) null + (cons (f) (repeat-fn (- n 1) f)))) + +;; tworzy tablicę n na m elementów, zawierającą świeże +;; zmienne logiczne +(define (make-rect n m) + (repeat-fn m (lambda () (repeat-fn n _)))) + +;; predykat binarny +;; (%row-ok xs ys) oznacza, że xs opisuje wiersz (lub kolumnę) ys +(define %row-ok + (%rel () +;; TODO: uzupełnij! + )) + +;; TODO: napisz potrzebne ci pomocnicze predykaty + +;; funkcja rozwiązująca zagadkę +(define (solve rows cols) + (define board (make-rect (length cols) (length rows))) + (define tboard (transpose board)) + (define ret (%which (xss) + (%= xss board) +;; TODO: uzupełnij! + )) + (and ret (cdar ret))) + +;; testy +(equal? (solve '((2) (1) (1)) '((1 1) (2))) + '((* *) + (_ *) + (* _))) + +(equal? (solve '((2) (2 1) (1 1) (2)) '((2) (2 1) (1 1) (2))) + '((_ * * _) + (* * _ *) + (* _ _ *) + (_ * * _))) + +(equal? (solve '((4) (6) (2 2) (2 2) (6) (4) (2) (2) (2)) + '((9) (9) (2 2) (2 2) (4) (4))) + '((* * * * _ _) + (* * * * * *) + (* * _ _ * *) + (* * _ _ * *) + (* * * * * *) + (* * * * _ _) + (* * _ _ _ _) + (* * _ _ _ _) + (* * _ _ _ _))) + +;; TODO: możesz dodać własne testy + diff --git a/semestr-2/racket/l14z22/solution.rkt b/semestr-2/racket/l14z22/solution.rkt new file mode 100644 index 0000000..480c772 --- /dev/null +++ b/semestr-2/racket/l14z22/solution.rkt @@ -0,0 +1,87 @@ +#lang racket + +(require racklog) + +(provide solve) + +;; transpozycja tablicy zakodowanej jako lista list +(define (transpose xss) + (cond [(null? xss) xss] + ((null? (car xss)) (transpose (cdr xss))) + [else (cons (map car xss) + (transpose (map cdr xss)))])) + +;; procedura pomocnicza +;; tworzy listę n-elementową zawierającą wyniki n-krotnego +;; wywołania procedury f +(define (repeat-fn n f) + (if (eq? 0 n) null + (cons (f) (repeat-fn (- n 1) f)))) + +;; tworzy tablicę n na m elementów, zawierającą świeże +;; zmienne logiczne +(define (make-rect n m) + (repeat-fn m (lambda () (repeat-fn n _)))) + +;; predykat binarny +;; (%row-ok xs ys) oznacza, że xs opisuje wiersz (lub kolumnę) ys +(define %row-ok + (%rel (xs ys zs n) + [(null null)] + [(xs (cons '_ ys)) + (%row-ok xs ys)] + [((cons n xs) ys) + (%stars ys n) + (%cut-first-n ys zs n) + (%row-ok xs zs)])) + + +(define %suffix + (%rel (xs ys x) + [(xs xs)] + [((cons x xs) ys) + (%suffix xs ys)])) + +(define %cut-first-n + (%rel (xs ys n yl) + [(xs xs 0)] + [(xs ys n) + (%suffix xs ys) + (%is #t (= (- (length xs) (length ys)) n))])) + + +;; usun n pierwszych elementow z xs +(define (suffix xs n) + (if (= n 0) + xs + (suffix (cdr xs) (- n 1)))) + + +;; sprawdza czy pierwsze n elementów listy to gwiazdki (dokladnie n) +(define %stars + (%rel (xs m n) + [(null 0)] + [((cons '_ xs) n) + (%is n 0)] + [((cons '* xs) n) + (%is m (- n 1)) + (%stars xs m)])) + +(define %board-ok + (%rel (xss xs yss ys) + [(null null)] + [((cons xs xss) (cons ys yss)) + (%row-ok xs ys) + (%board-ok xss yss)])) + +;; funkcja rozwiązująca zagadkę +(define (solve rows cols) + (define board (make-rect (length cols) (length rows))) + (define tboard (transpose board)) + (define ret (%which (xss) + (%= xss board) + (%board-ok rows board) + (%board-ok cols tboard))) + (and ret (cdar ret))) + + diff --git a/semestr-2/racket/l15/kacp.bak b/semestr-2/racket/l15/kacp.bak new file mode 100644 index 0000000..ff2a2bc --- /dev/null +++ b/semestr-2/racket/l15/kacp.bak @@ -0,0 +1,55 @@ +#lang racket + +(define (run-concurrent . thunks) + (define threads (map thread thunks)) + (for-each thread-wait threads)) + +(define (random-sleep) + (sleep (/ (random) 100))) + +(define (with-random-sleep proc) + (lambda args + (random-sleep) + (apply proc args))) + +(define (make-serializer) + (define sem (make-semaphore 1)) + (lambda (proc) + (lambda args + (semaphore-wait sem) + (define ret (apply proc args)) + (semaphore-post sem) + ret))) + +(define (table) + (random-sleep) + (define forks (list (make-semaphore 1) + (make-semaphore 1) + (make-semaphore 1) + (make-semaphore 1) + (make-semaphore 1))) + (define (pick-fork i) + (random-sleep) + (semaphore-wait (list-ref forks i))) + (define (put-fork i) + (random-sleep) + (semaphore-post (list-ref forks i))) + (define (dispatch m) + (cond [(eq? m 'pick-fork) pick-fork] + [(eq? m 'put-fork) put-fork] + [else (error "Unknown request -- TABLE" + m)])) + dispatch) + +(define dtable (table)) + +(define (philosopher dining-table number) + (define my-turn (make-serializer)) + (define (eat) + (display number) + (newline) + ((dining-table 'pick-fork) number) + ((dining-table 'put-fork) number) + ((dining-table 'pick-fork) (modulo (+ number 1) 5)) + ((dining-table 'put-fork) (modulo (+ number 1) 5))) + (my-turn eat)) \ No newline at end of file diff --git a/semestr-2/racket/l15/kacp.rkt b/semestr-2/racket/l15/kacp.rkt new file mode 100644 index 0000000..bd484f1 --- /dev/null +++ b/semestr-2/racket/l15/kacp.rkt @@ -0,0 +1,59 @@ +#lang racket + +(define (run-concurrent . thunks) + (define threads (map thread thunks)) + (for-each thread-wait threads)) + +(define (random-sleep) + (sleep (/ (random) 100))) + +(define (with-random-sleep proc) + (lambda args + (random-sleep) + (apply proc args))) + +(define (make-serializer) + (define sem (make-semaphore 1)) + (lambda (proc) + (lambda args + (semaphore-wait sem) + (define ret (apply proc args)) + (semaphore-post sem) + ret))) + +(define (table) + (random-sleep) + (define forks (list (make-semaphore 1) + (make-semaphore 1) + (make-semaphore 1) + (make-semaphore 1) + (make-semaphore 1))) + (define (pick-fork i) + (random-sleep) + (semaphore-wait (list-ref forks i))) + (define (put-fork i) + (random-sleep) + (semaphore-post (list-ref forks i))) + (define (dispatch m) + (cond [(eq? m 'pick-fork) pick-fork] + [(eq? m 'put-fork) put-fork] + [else (error "Unknown request -- TABLE" + m)])) + dispatch) + +(define dtable (table)) + +(define (philosopher dining-table number) + (define my-turn (make-serializer)) + (define (eat) + (display "Zaczynam ") + (display number) + (newline) + ((dining-table 'pick-fork) number) + ((dining-table 'put-fork) number) + ((dining-table 'pick-fork) (modulo (+ number 1) 5)) + ((dining-table 'put-fork) (modulo (+ number 1) 5)) + (display "Koncze ") + (display number) + (newline)) + (my-turn eat)) \ No newline at end of file diff --git a/semestr-2/racket/l15/solution.bak b/semestr-2/racket/l15/solution.bak new file mode 100644 index 0000000..03ab86a --- /dev/null +++ b/semestr-2/racket/l15/solution.bak @@ -0,0 +1,7 @@ +#lang racket + + + +(define (run-concurrent . thunks) + (define threads (map thread thunks)) + (for-each thread-wait threads)) \ No newline at end of file diff --git a/semestr-2/racket/l15/solution.rkt b/semestr-2/racket/l15/solution.rkt new file mode 100644 index 0000000..915502e --- /dev/null +++ b/semestr-2/racket/l15/solution.rkt @@ -0,0 +1,85 @@ +#lang racket + +(provide philosopher) + +;; Do debugu + +(define (run-concurrent . thunks) + (define threads (map thread thunks)) + (for-each thread-wait threads)) + +(define (random-sleep) + (sleep (/ (random) 100))) + +(define (with-random-sleep proc) + (lambda args + (random-sleep) + (apply proc args))) + +(define (make-serializer) + (define sem (make-semaphore 1)) + (lambda (proc) + (lambda args + (semaphore-wait sem) + (define ret (apply proc args)) + (semaphore-post sem) + ret))) + +(define (make-table) + (define forks (map (lambda (x) (make-semaphore 1)) '(0 1 2 3 4))) + (define (get-fork i) + (list-ref forks i)) + (define (pick-fork i) + (random-sleep) + (semaphore-wait (get-fork i))) + (define (put-fork i) + (random-sleep) + (semaphore-post (get-fork i))) + (define (dispatch m) + (cond [(eq? m 'pick-fork) pick-fork] + [(eq? m 'put-fork) put-fork] + [else (error "Unknown request -- MAKE-TABLE" m)])) + dispatch) + +;(define dining-table (make-table)) + +;(define (repeat proc n) +; (if (> n 0) +; (begin +; (proc) +; (repeat proc (- n 1))) +; #f)) +; +;(define (hungry nr x) +; (lambda () (repeat (lambda () (philosopher dining-table nr)) x))) + +;; Rozwiązanie: + +(define forks-sem (map (lambda (x) (make-semaphore 1)) '(0 0 0 0 0))) + +(define (get-fork i) + (list-ref forks-sem i)) + +(define (is-free? i) + (semaphore-try-wait? (get-fork i))) + +(define (put-fork dining-table i) + ((dining-table 'put-fork) i) + (semaphore-post (get-fork i))) + +(define (philosopher dining-table i) + (define left-fork i) + (define right-fork (modulo (+ i 1) 5)) + (define (loop) + (if (is-free? left-fork) + (if (is-free? right-fork) + (begin + ((dining-table 'pick-fork) left-fork) + ((dining-table 'pick-fork) right-fork) + (put-fork dining-table left-fork) + (put-fork dining-table right-fork)) + (loop)) + (begin + (semaphore-post (get-fork left-fork)) + (loop)))) + (loop)) \ No newline at end of file diff --git a/semestr-2/racket/l7z12/solution.rkt b/semestr-2/racket/l7z12/solution.rkt new file mode 100644 index 0000000..089dee4 --- /dev/null +++ b/semestr-2/racket/l7z12/solution.rkt @@ -0,0 +1,95 @@ +#lang racket + +(provide (struct-out const) + (struct-out binop) + (struct-out var-expr) + (struct-out let-expr) + (struct-out pos) + (struct-out var-free) + (struct-out var-bound) + annotate-expression) + +;; --------------- +;; Jezyk wejsciowy +;; --------------- + +(struct pos (file line col) #:transparent) + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (loc id e1 e2) #:transparent) + +(define (expr? e) + (match e + [(const n) (number? n)] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr loc x e1 e2) + (and (pos? loc) (symbol? x) (expr? e1) (expr? e2))] + [_ false])) + +(define (make-pos s) + (pos (syntax-source s) + (syntax-line s) + (syntax-column s))) + +(define (parse e) + (let ([r (syntax-e e)]) + (cond + [(number? r) (const r)] + [(symbol? r) (var-expr r)] + [(and (list? r) (= 3 (length r))) + (match (syntax-e (car r)) + ['let (let* ([e-def (syntax-e (second r))] + [x (syntax-e (first e-def))]) + (let-expr (make-pos (first e-def)) + (if (symbol? x) x (error "parse error!")) + (parse (second e-def)) + (parse (third r))))] + [op (binop op (parse (second r)) (parse (third r)))])] + [else (error "parse error!")]))) + +;; --------------- +;; Jezyk wyjsciowy +;; --------------- + +(struct var-free (id) #:transparent) +(struct var-bound (pos id) #:transparent) + +(define (expr-annot? e) + (match e + [(const n) (number? n)] + [(binop op l r) (and (symbol? op) (expr-annot? l) (expr-annot? r))] + [(var-free x) (symbol? x)] + [(var-bound loc x) (and (pos? loc) (symbol? x))] + [(let-expr loc x e1 e2) + (and (pos? loc) (symbol? x) (expr-annot? e1) (expr-annot? e2))] + [_ false])) + +(struct environ (xs)) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) false] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +(define (annotate-expression-env e env) + (match e + [(const r) (const r)] + [(binop op l r) (binop op (annotate-expression-env l env) (annotate-expression-env r env))] + [(var-expr x) (let ((pos (env-lookup x env))) + (if pos + (var-bound pos x) + (var-free x)))] + [(let-expr loc x e1 e2) (let-expr loc x (annotate-expression-env e1 env) (annotate-expression-env e2 (env-add x loc env)))])) + +(define (annotate-expression e) + (annotate-expression-env e env-empty)) + +(define (test) (annotate-expression (parse #'(let [x 5] (let [x (* x y)] (+ x y)))))) diff --git a/semestr-2/racket/l7z13/solution.rkt b/semestr-2/racket/l7z13/solution.rkt new file mode 100644 index 0000000..0a0278a --- /dev/null +++ b/semestr-2/racket/l7z13/solution.rkt @@ -0,0 +1,104 @@ +#lang racket + +(provide (struct-out const) (struct-out binop) (struct-out var-expr) (struct-out let-expr) (struct-out var-dead) find-dead-vars) + + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct var-dead (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) + +(define (expr? e) + (match e + [(const n) (number? n)] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(var-dead x) (symbol? x)] + [(let-expr x e1 e2) (and (symbol? x) (expr? e1) (expr? e2))] + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))])) + +; ---------------------------------- ; +; Wyszukaj ostatnie uzycie zmiennych ; +; ---------------------------------- ; + +(struct environ (xs)) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "unbound identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) +(define (env-erase x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "unbound identifier" x)] + [(eq? x (caar xs)) (cdr xs)] + [else (cons (car xs) (assoc-lookup (cdr xs)))])) + (if (env-lookup x env) + (environ (assoc-lookup (assoc-lookup (environ-xs env)))) + (environ (assoc-lookup (environ-xs env))))) + + +(define (find-dead-vars-env e env) + (match e + [(const r) (cons (const r) env)] + [(var-expr x) (if (env-lookup x env) + (cons (var-expr x) env) + (cons (var-dead x) (env-add x true env)))] + [(binop op l r) (let* ((right-expr (find-dead-vars-env r env)) + (r (car right-expr)) + (env (cdr right-expr)) + (left-expr (find-dead-vars-env l env)) + (l (car left-expr)) + (env (cdr left-expr))) + (cons (binop op l r) env))] + [(let-expr x e1 e2) (let* ((right-expr (find-dead-vars-env e2 (env-add x false env))) + (e2 (car right-expr)) + (env (env-erase x (cdr right-expr))) + (left-expr (find-dead-vars-env e1 env)) + (e1 (car left-expr)) + (env (cdr left-expr))) + (cons (let-expr x e1 e2) env))])) + +(define (find-dead-vars e) + (car (find-dead-vars-env e env-empty))) + + +(define (sample2) (find-dead-vars (let-expr 'x (const 3) + (binop '+ (var-expr 'x) + (let-expr 'x (const 5) (binop '+ (var-expr 'x) (var-expr 'x))))))) + +(define (test1) (find-dead-vars (parse '(let (x 3) (let (x (* x (+ x x))) (+ x x)))))) +(define (test2) (find-dead-vars (parse '(let (x 2) (let [x (let [x (+ x 2)] x)] x))))) +(define (test3) (find-dead-vars (parse '(let [x 2] (+ (let [x (+ 2 x)] (* 3 x)) x))))) +(define (test4) (find-dead-vars (parse '(let [x 2] (let [x (+ x 3)] (* x x)))))) +(define (test5) (find-dead-vars (parse '(let [x 2] (+ x (let [x (+ 2 x)] x)))))) +(define (test6) (find-dead-vars (parse '(let [x 2] + (let [y (let [x (* x (+ x x))] + (let [y (* x x)] + (+ y 2)))] + (+ x (* y y))))))) +(define (test7) (find-dead-vars (parse '(let [x (let [x (let [x 2] (+ x x))] (+ x x))] (+ x x))))) +;;; (define (test7) (find-dead-vars (parse '(let [x (let [x (let [x 2] (let (x 2) (+ x x)))] (+ x x))] (+ x x))))) +(define (test8) (find-dead-vars (parse '(let [x 2] (let [x 2] (+ x x)))))) \ No newline at end of file diff --git a/semestr-2/racket/l8z14/solution.bak b/semestr-2/racket/l8z14/solution.bak new file mode 100644 index 0000000..b51383a --- /dev/null +++ b/semestr-2/racket/l8z14/solution.bak @@ -0,0 +1,155 @@ +#lang racket + +; Do list.rkt dodajemy procedury +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct cons-expr (e1 e2) #:transparent) +(struct car-expr (e) #:transparent) +(struct cdr-expr (e) #:transparent) +(struct null-expr () #:transparent) +(struct null?-expr (e) #:transparent) +(struct app (f e) #:transparent) ; <------------------ !!! +(struct lam (id e) #:transparent) ; <------------------ !!! + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) + (and (expr? eb) (expr? et) (expr? ef))] + [(cons-expr e1 e2) (and (expr? e1) (expr? e2))] + [(car-expr e) (expr? e)] + [(cdr-expr e) (expr? e)] + [(null-expr) true] + [(null?-expr e) (expr? e)] + [(app f e) (and (expr? f) (expr? e))] ; <--------------------- !!! + [(lam id e) (and (symbol? id) (expr? e))] ; <----------------- !!! + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (null-expr)] + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'null?)) + (null?-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'cons)) + (cons-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'car)) + (car-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'cdr)) + (cdr-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'lambda)) ; proc (car q)))) ; <------- !!! + (parse-app q)] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))])) + +(define (parse-app q) ; <----------------------------------------- !!! + (define (parse-app-accum q acc) + (cond [(= 1 (length q)) (app acc (parse (car q)))] + [else (parse-app-accum (cdr q) (app acc (parse (car q))))])) + (parse-app-accum (cdr q) (parse (car q)))) + +(define (parse-lam pat e) ; <------------------------------------- !!! + (cond [(= 1 (length pat)) + (lam (car pat) (parse e))] + [else + (lam (car pat) (parse-lam (cdr pat) e))])) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs) #:transparent) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(struct clo (id e env) #:transparent) ; <------------------------- !!! + +(define (value? v) + (or (number? v) + (boolean? v) + (and (pair? v) (value? (car v)) (value? (cdr v))) + (null? v) + (clo? v))) ; <---------------------------------------------- !!! + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))] + [_ false])) ; <--------------------------------------- !!! + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) + (eval-env et env) + (eval-env ef env))] + [(cons-expr e1 e2) (cons (eval-env e1 env) + (eval-env e2 env))] + [(car-expr e) (car (eval-env e env))] + [(cdr-expr e) (cdr (eval-env e env))] + [(null-expr) null] + [(null?-expr e) (null? (eval-env e env))] + [(lam x e) (clo x e env)] ; <--------------------------------- !!! + [(app f e) ; <------------------------------------------------ !!! + (let ([vf (eval-env f env)] + [ve (eval-env e env)]) + (match vf [(clo x body fun-env) + (eval-env body (env-add x ve fun-env))]))])) + +(define (eval e) (eval-env e env-empty)) + +(define program + '(let [twice (lambda (f x) (f (f x)))] + (let [inc (lambda (x) (+ 1 x))] + (twice twice twice twice inc 1)))) + + +(define (test-eval) (eval (parse program))) \ No newline at end of file diff --git a/semestr-2/racket/l8z14/solution.rkt b/semestr-2/racket/l8z14/solution.rkt new file mode 100644 index 0000000..59556cf --- /dev/null +++ b/semestr-2/racket/l8z14/solution.rkt @@ -0,0 +1,201 @@ +#lang racket + +; Do list.rkt dodajemy procedury +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(provide eval parse) + + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct cons-expr (e1 e2) #:transparent) +(struct car-expr (e) #:transparent) +(struct cdr-expr (e) #:transparent) +(struct null-expr () #:transparent) +(struct null?-expr (e) #:transparent) +(struct app (f e) #:transparent) ; <------------------ !!! +(struct lam (id e) #:transparent) ; <------------------ !!! +(struct apply-expr (f xs) #:transparent) + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) + (and (expr? eb) (expr? et) (expr? ef))] + [(cons-expr e1 e2) (and (expr? e1) (expr? e2))] + [(car-expr e) (expr? e)] + [(cdr-expr e) (expr? e)] + [(null-expr) true] + [(null?-expr e) (expr? e)] + [(app f e) (and (expr? f) (expr? e))] ; <--------------------- !!! + [(lam id e) (and (symbol? id) (expr? e))] ; <----------------- !!! + [(apply-expr f xs) (and (expr? f) (expr? xs))] + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (null-expr)] + [(symbol? q) (var-expr q)] + [(and (> (length q) 0) (list? q) (eq? (first q) 'list)) + (parse-list (cdr q))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'null?)) + (null?-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'apply)) + (apply-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'cons)) + (cons-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'car)) + (car-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'cdr)) + (cdr-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'lambda)) ; proc (car q)))) ; <------- !!! + (parse-app q)] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))])) + + +(define (parse-app q) ; <----------------------------------------- !!! + (define (parse-app-accum q acc) + (cond [(= 1 (length q)) (app acc (parse (car q)))] + [else (parse-app-accum (cdr q) (app acc (parse (car q))))])) + (parse-app-accum (cdr q) (parse (car q)))) + +(define (parse-lam pat e) ; <------------------------------------- !!! + (cond [(= 1 (length pat)) + (lam (car pat) (parse e))] + [else + (lam (car pat) (parse-lam (cdr pat) e))])) + +(define (parse-list q) + (if (null? q) + (null-expr) + (cons-expr (parse (car q)) (parse-list (cdr q))))) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs) #:transparent) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(struct clo (id e env) #:transparent) ; <------------------------- !!! + +(define (value? v) + (or (number? v) + (boolean? v) + (and (pair? v) (value? (car v)) (value? (cdr v))) + (null? v) + (clo? v))) ; <---------------------------------------------- !!! + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))] + [_ false])) ; <--------------------------------------- !!! + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) + (eval-env et env) + (eval-env ef env))] + [(cons-expr e1 e2) (cons (eval-env e1 env) + (eval-env e2 env))] + [(car-expr e) (car (eval-env e env))] + [(cdr-expr e) (cdr (eval-env e env))] + [(null-expr) null] + [(null?-expr e) (null? (eval-env e env))] + [(apply-expr e1 e2) + (let ([xs (eval-env e2 env)]) + (eval-env (eval-apply e1 (reverse xs)) env))] + [(lam x e) (clo x e env)] ; <--------------------------------- !!! + [(app f e) ; <------------------------------------------------ !!! + (let ([vf (eval-env f env)] + [ve (eval-env e env)]) + (match vf [(clo x body fun-env) + (eval-env body (env-add x ve fun-env))]))])) + +(define (eval-apply e xs) + (if (null? xs) + e + (app (eval-apply e (cdr xs)) (const (car xs))))) + +(define (eval e) (eval-env e env-empty)) + +;; testy wspólnie z Karolem Ochmanem + +(define program1 + '(apply (lambda (x y) (+ x y)) + (cons 1 (cons 2 null)))) +(define program2 + '(apply (lambda (x y z) (+ x (+ y z))) + (cons 1 (cons 2 null)))) +(define program3 + '(apply (lambda (x y) (lambda (z) (+ x (+ y z)))) + (cons 1 (cons 2 (cons 3 null))))) +(define program4 + '(apply (lambda (x y) (+ x y)) + (cons 1 (cons 2 (cons 3 null))))) +(define program5 + '(let [f (lambda (x y z) (+ z (+ x y)))] + (apply (f 3) (cons 1 (cons 2 null))))) +(define program6 + '(let [f (lambda (x) x)] + (apply (f 4) null))) +(define program7 + '(apply (lambda (q w e r t y u i o p a s d f g h j k l) 3) + (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 + (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 + (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 null))))))))))))))))))))) +(define program8 + '(apply (lambda (q w e r t y u i o p a s d f g h j k l) 3) + (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 (cons 1 + (cons 1 (cons 1 (cons 1 (cons 1 null))))))))))))))) \ No newline at end of file diff --git a/semestr-2/racket/l8z15/solution.bak b/semestr-2/racket/l8z15/solution.bak new file mode 100644 index 0000000..cdc84f9 --- /dev/null +++ b/semestr-2/racket/l8z15/solution.bak @@ -0,0 +1,187 @@ +#lang racket + +; Do list.rkt dodajemy procedury +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +(provide parse eval) + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct cons-expr (e1 e2) #:transparent) +(struct car-expr (e) #:transparent) +(struct cdr-expr (e) #:transparent) +(struct null-expr () #:transparent) +(struct null?-expr (e) #:transparent) +(struct app (f e) #:transparent) ; <------------------ !!! +(struct lam (id e) #:transparent) ; <------------------ !!! + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) + (and (expr? eb) (expr? et) (expr? ef))] + [(cons-expr e1 e2) (and (expr? e1) (expr? e2))] + [(car-expr e) (expr? e)] + [(cdr-expr e) (expr? e)] + [(null-expr) true] + [(null?-expr e) (expr? e)] + [(app f e) (and (expr? f) (expr? e))] ; <--------------------- !!! + [(lam id e) (and (symbol? id) (expr? e))] ; <----------------- !!! + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (null-expr)] + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'null?)) + (null?-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'cons)) + (cons-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'car)) + (car-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'cdr)) + (cdr-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'lambda)) ; proc (car q)))) ; <------- !!! + (parse-app q)] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))])) + +(define (parse-app q) ; <----------------------------------------- !!! + (define (parse-app-accum q acc) + (cond [(= 1 (length q)) (app acc (parse (car q)))] + [else (parse-app-accum (cdr q) (app acc (parse (car q))))])) + (parse-app-accum (cdr q) (parse (car q)))) + +(define (parse-lam pat e) ; <------------------------------------- !!! + (cond [(= 1 (length pat)) + (lam (car pat) (parse e))] + [else + (lam (car pat) (parse-lam (cdr pat) e))])) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs) #:transparent) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(struct clo (id e env) #:transparent) ; <------------------------- !!! +(struct odr (e env) #:transparent) + +(define (value? v) + (or (number? v) + (boolean? v) + (and (pair? v) (value? (car v)) (value? (cdr v))) + (null? v) + (clo? v))) ; <---------------------------------------------- !!! + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))] + [_ false])) ; <--------------------------------------- !!! + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (match (env-lookup x env) + [(odr e env) (eval-env e env)] + [f f])] + [(if-expr eb et ef) (if (eval-env eb env) + (eval-env et env) + (eval-env ef env))] + [(cons-expr e1 e2) (cons (odr e1 env) + (odr e2 env))] + [(car-expr e) (let ([p (eval-env e env)]) + (match (car p) + [(odr e env) (eval-env e env)]))] + [(cdr-expr e) (let ([p (eval-env e env)]) + (match (cdr p) + [(odr e env) (eval-env e env)]))] + [(null-expr) null] + [(null?-expr e) (null? (eval-env e env))] + [(lam x e) (clo x e env)] ; <--------------------------------- !!! + [(app f e) ; <------------------------------------------------ !!! + (let ([vf (eval-env f env)] + [ve (odr e env)]) + (match vf [(clo x body fun-env) + (eval-env body (env-add x ve fun-env))]))])) + +(define (eval e) (eval-env e env-empty)) + +(define program + '(let [twice (lambda (f x) (f (f x)))] + (let [inc (lambda (x) (+ 1 x))] + (twice twice twice twice inc 1)))) + + +;;; Testy wspólnie z Karolem Ochmanem + +(define (test-eval program) (eval (parse program))) + +(define program1 + '((lambda (x) (+ 3 3)) (/ 5 0))) +(define program2 + '(let [if-fun (lambda (b t e) (if b t e))] + (if-fun true 4 (/ 5 0)))) +(define program3 + '(car (cdr (cons 1 (cons 2 (cons 3 (cons 4 null))))))) +(define program4 + '(car (cons (+ 3 4) (/ 5 0)))) +(define program5 + '(cons (+ 5 6) (- 4 3))) +(define program6 + '(car (cdr (cdr (car (cons (cons (/ 0 0) (cons (/ 0 0) (cons 1 (/ 0 0)))) (cdr (cons (/ 0 0) null)))))))) +;;; (test-eval program) +;;; (test-eval program1) +;;; (test-eval program2) +;;; (test-eval program3) +;;; (test-eval program4) +;;; (test-eval program5) +;;; (test-eval program6) \ No newline at end of file diff --git a/semestr-2/racket/l8z15/solution.rkt b/semestr-2/racket/l8z15/solution.rkt new file mode 100644 index 0000000..54b6cd3 --- /dev/null +++ b/semestr-2/racket/l8z15/solution.rkt @@ -0,0 +1,182 @@ +#lang racket + +; Do list.rkt dodajemy procedury +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +(provide parse eval) + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct cons-expr (e1 e2) #:transparent) +(struct car-expr (e) #:transparent) +(struct cdr-expr (e) #:transparent) +(struct null-expr () #:transparent) +(struct null?-expr (e) #:transparent) +(struct app (f e) #:transparent) ; <------------------ !!! +(struct lam (id e) #:transparent) ; <------------------ !!! + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) + (and (expr? eb) (expr? et) (expr? ef))] + [(cons-expr e1 e2) (and (expr? e1) (expr? e2))] + [(car-expr e) (expr? e)] + [(cdr-expr e) (expr? e)] + [(null-expr) true] + [(null?-expr e) (expr? e)] + [(app f e) (and (expr? f) (expr? e))] ; <--------------------- !!! + [(lam id e) (and (symbol? id) (expr? e))] ; <----------------- !!! + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (null-expr)] + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'null?)) + (null?-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'cons)) + (cons-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'car)) + (car-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'cdr)) + (cdr-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'lambda)) ; proc (car q)))) ; <------- !!! + (parse-app q)] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))])) + +(define (parse-app q) ; <----------------------------------------- !!! + (define (parse-app-accum q acc) + (cond [(= 1 (length q)) (app acc (parse (car q)))] + [else (parse-app-accum (cdr q) (app acc (parse (car q))))])) + (parse-app-accum (cdr q) (parse (car q)))) + +(define (parse-lam pat e) ; <------------------------------------- !!! + (cond [(= 1 (length pat)) + (lam (car pat) (parse e))] + [else + (lam (car pat) (parse-lam (cdr pat) e))])) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs) #:transparent) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(struct clo (id e env) #:transparent) ; <------------------------- !!! +(struct odr (e env) #:transparent) + +(define (value? v) + (or (number? v) + (boolean? v) + (and (pair? v) (value? (car v)) (value? (cdr v))) + (null? v) + (clo? v))) ; <---------------------------------------------- !!! + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))] + [_ false])) ; <--------------------------------------- !!! + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (match (env-lookup x env) + [(odr e env) (eval-env e env)] + [f f])] + [(if-expr eb et ef) (if (eval-env eb env) + (eval-env et env) + (eval-env ef env))] + [(cons-expr e1 e2) (cons (odr e1 env) + (odr e2 env))] + [(car-expr e) (let ([p (eval-env e env)]) + (match (car p) + [(odr e env) (eval-env e env)]))] + [(cdr-expr e) (let ([p (eval-env e env)]) + (match (cdr p) + [(odr e env) (eval-env e env)]))] + [(null-expr) null] + [(null?-expr e) (null? (eval-env e env))] + [(lam x e) (clo x e env)] ; <--------------------------------- !!! + [(app f e) ; <------------------------------------------------ !!! + (let ([vf (eval-env f env)] + [ve (odr e env)]) + (match vf [(clo x body fun-env) + (eval-env body (env-add x ve fun-env))]))])) + +(define (eval e) (eval-env e env-empty)) + + +;;; Testy wspólnie z Karolem Ochmanem + +(define (test-eval program) (eval (parse program))) + +(define program1 + '((lambda (x) (+ 3 3)) (/ 5 0))) +(define program2 + '(let [if-fun (lambda (b t e) (if b t e))] + (if-fun true 4 (/ 5 0)))) +(define program3 + '(car (cdr (cons 1 (cons 2 (cons 3 (cons 4 null))))))) +(define program4 + '(car (cons (+ 3 4) (/ 5 0)))) +(define program5 + '(cons (+ 5 6) (- 4 3))) +(define program6 + '(car (cdr (cdr (car (cons (cons (/ 0 0) (cons (/ 0 0) (cons 1 (/ 0 0)))) (cdr (cons (/ 0 0) null)))))))) +;;; (test-eval program) +;;; (test-eval program1) +;;; (test-eval program2) +;;; (test-eval program3) +;;; (test-eval program4) +;;; (test-eval program5) +;;; (test-eval program6) \ No newline at end of file diff --git a/semestr-2/racket/l9/zad4.rkt b/semestr-2/racket/l9/zad4.rkt new file mode 100644 index 0000000..7b5e0bc --- /dev/null +++ b/semestr-2/racket/l9/zad4.rkt @@ -0,0 +1,202 @@ +#lang racket + +; Do fun.rkt dodajemy rekurencyjne let-y +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct letrec-expr (id e1 e2) #:transparent) ; <----------------- !!! +(struct if-expr (eb et ef) #:transparent) +(struct cons-expr (e1 e2) #:transparent) +(struct car-expr (e) #:transparent) +(struct cdr-expr (e) #:transparent) +(struct null-expr () #:transparent) +(struct null?-expr (e) #:transparent) +(struct app (f e) #:transparent) +(struct lam (id e) #:transparent) +(struct citation (q) #:transparent) + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(letrec-expr x e1 e2) ; <------------------------------------ !!! + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) + (and (expr? eb) (expr? et) (expr? ef))] + [(cons-expr e1 e2) (and (expr? e1) (expr? e2))] + [(car-expr e) (expr? e)] + [(cdr-expr e) (expr? e)] + [(null-expr) true] + [(null?-expr e) (expr? e)] + [(app f e) (and (expr? f) (expr? e))] + [(lam id e) (and (symbol? id) (expr? e))] + [(citation q) true] + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (null-expr)] + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? 'quote (first q))) (citation (second q))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'null?)) + (null?-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'cons)) + (cons-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'car)) + (car-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'cdr)) + (cdr-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'letrec)) ; proc (car q)))) + (parse-app q)] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))])) + +(define (parse-app q) + (define (parse-app-accum q acc) + (cond [(= 1 (length q)) (app acc (parse (car q)))] + [else (parse-app-accum (cdr q) (app acc (parse (car q))))])) + (parse-app-accum (cdr q) (parse (car q)))) + +(define (parse-lam pat e) + (cond [(= 1 (length pat)) + (lam (car pat) (parse e))] + [else + (lam (car pat) (parse-lam (cdr pat) e))])) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct blackhole () #:transparent) ; <------------------------- !!! +(struct environ (xs) #:transparent) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (mcons x v) (environ-xs env)))) ; <-------------- !!! +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (mcar (car xs))) ; <---------------------------- !!! + (match (mcdr (car xs)) + [(blackhole) (error "Stuck forever in a black hole!")] + [x x])] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) +(define (env-update! x v xs) ; <---------------------------------- !!! + (define (assoc-update! xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (mcar (car xs))) (set-mcdr! (car xs) v)] + [else (env-update! x v (cdr xs))])) + (assoc-update! (environ-xs xs))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(struct clo (id e env) #:transparent) + +(define (value? v) + (or (number? v) + (boolean? v) + (and (pair? v) (value? (car v)) (value? (cdr v))) + (null? v) + (clo? v) + (blackhole? v))) ; <---------------------------------------- !!! + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))] + [_ false])) + +(define (eval-env e env) + (match e + [(const n) n] + [(citation q) q] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(letrec-expr x e1 e2) ; <------------------------------------ !!! + (let* ([new-env (env-add x (blackhole) env)] + [v (eval-env e1 new-env)]) + (begin + (env-update! x v new-env) + (eval-env e2 new-env)))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) + (eval-env et env) + (eval-env ef env))] + [(cons-expr e1 e2) (cons (eval-env e1 env) + (eval-env e2 env))] + [(car-expr e) (car (eval-env e env))] + [(cdr-expr e) (cdr (eval-env e env))] + [(null-expr) null] + [(null?-expr e) (null? (eval-env e env))] + [(lam x e) (clo x e env)] + [(app f e) + (let ([vf (eval-env f env)] + [ve (eval-env e env)]) + (match vf [(clo x body fun-env) + (eval-env body (env-add x ve fun-env))]))])) + +(define (eval e) (eval-env e env-empty)) + +(define program + '(letrec + [fact (lambda (n) (if (= n 0) 1 (* n (fact (- n 1)))))] + (letrec + [even-odd + (cons + (lambda (x) + (if (= x 0) true ((cdr even-odd) (- x 1)))) + (lambda (x) + (if (= x 0) false ((car even-odd) (- x 1)))))] + (let [even (car even-odd)] + (let [odd (cdr even-odd)] + (even (fact 6))))))) + +(define PROGRAM + '(letrec [from-to (lambda (n k) + (if (> n k) + null + (cons n (from-to (+ n 1) k))))] + (letrec [sum (lambda (xs) + (if (null? xs) + 0 + (+ (car xs) (sum (cdr xs)))))] + (sum (from-to 1 36))))) + +(define (test-eval) (eval (parse PROGRAM))) \ No newline at end of file diff --git a/semestr-2/racket/l9/zad7.rkt b/semestr-2/racket/l9/zad7.rkt new file mode 100644 index 0000000..207162d --- /dev/null +++ b/semestr-2/racket/l9/zad7.rkt @@ -0,0 +1,340 @@ +#lang racket + +;; Składnia abstrakcyjna +(struct const (val) #:transparent) +(struct var-expr (name) #:transparent) +(struct let-expr (id bound body) #:transparent) +(struct letrec-expr (id bound body) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct lambda-expr (arg body) #:transparent) +(struct app-expr (fun arg) #:transparent) +(struct display-expr (e) ) + +(define (keyword s) + (member s '(true false null and or if cond else lambda let letrec display read))) + +(define (expr? e) + (match e + [(const n) (or (number? n) + (boolean? n) + (null? n) + (string? n))] + [(var-expr id) (symbol? id)] + [(let-expr x e1 e2 ) (and (symbol? x) + (expr? e1) + (expr? e2))] + [(letrec-expr x e1 e2) (and (symbol? x) + (expr? e1) + (expr? e2))] + [(if-expr eb et ef) (and (expr? eb) + (expr? et) + (expr? ef))] + [(lambda-expr x e) (and (symbol? x) + (expr? e))] + [(app-expr ef ea) (and (expr? ef) + (expr? ea))] + [_ false])) + +;; Parsowanie (zacytowane wyrażenie -> składnia abstrakcyjna) +(define (parse q) + (cond + [(number? q) (const q)] + [(string? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (const null)] + [(and (symbol? q) + (not (keyword q))) + (var-expr q)] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'let) + (list? (second q)) + (= (length (second q)) 2) + (symbol? (first (second q)))) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'letrec) + (list? (second q)) + (= (length (second q)) 2) + (symbol? (first (second q)))) + (letrec-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) + (= (length q) 4) + (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) + (pair? q) + (eq? (first q) 'and)) + (desugar-and (map parse (cdr q)))] + [(and (list? q) + (pair? q) + (eq? (first q) 'or)) + (desugar-or (map parse (cdr q)))] + [(and (list? q) + (>= (length q) 2) + (eq? (first q) 'cond)) + (parse-cond (cdr q))] + [(and (list? q) + (= (length q) 3) + (eq? (first q) 'lambda) + (list? (second q)) + (andmap symbol? (second q)) + (cons? (second q))) + (desugar-lambda (second q) (parse (third q)))] + [(and (list? q) + (>= (length q) 2)) + (desugar-app (parse (first q)) (map parse (cdr q)))] + [else (error "Unrecognized token:" q)])) + +(define (parse-cond qs) + (match qs + [(list (list 'else q)) + (parse q)] + + [(list (list q _)) + (error "Expected 'else' in last branch but found:" q)] + + [(cons (list qb qt) qs) + (if-expr (parse qb) (parse qt) (parse-cond qs))])) + +(define (desugar-and es) + (if (null? es) + (const true) + (if-expr (car es) (desugar-and (cdr es)) (const false)))) + +(define (desugar-or es) + (if (null? es) + (const false) + (if-expr (car es) (const true) (desugar-or (cdr es))))) + +(define (desugar-lambda xs e) + (if (null? xs) + e + (lambda-expr (car xs) (desugar-lambda (cdr xs) e)))) + +(define (desugar-app e es) + (if (null? es) + e + (desugar-app (app-expr e (car es)) (cdr es)))) + +;; Środowiska +(struct blackhole ()) +(struct environ (xs)) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (mcons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) + (error "Unknown identifier" x)] + [(eq? x (mcar (car xs))) + (let ((v (mcdr (car xs)))) + (if (blackhole? v) + (error "Jumped into blackhole at" x) + v))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) +(define (env-update! x v env) + (define (assoc-update xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (mcar (car xs))) + (set-mcdr! (car xs) v)] + [else (assoc-update (cdr xs))])) + (assoc-update (environ-xs env))) + +;; Domknięcia +(struct clo (arg body env)) + +;; Procedury wbudowane, gdzie +;; proc — Racketowa procedura którą należy uruchomić +;; args — lista dotychczas dostarczonych argumentów +;; pnum — liczba brakujących argumentów (> 0) +;; W ten sposób pozwalamy na częściową aplikację Racketowych procedur +;; — zauważmy że zawsze znamy pnum, bo w naszym języku arność +;; procedury jest ustalona z góry +(struct builtin (proc args pnum)) + +;; Pomocnicze konstruktory procedur unarnych i binarnych +(define (builtin/1 p) + (builtin p null 1)) +(define (builtin/2 p) + (builtin p null 2)) + +;; Procedury +(define (proc? v) + (or (and (clo? v) + (symbol? (clo-arg v)) + (expr? (clo-body v)) + (environ? (clo-env v))) + (and (builtin? v) + (procedure? (builtin-proc v)) + (andmap value? (builtin-args v)) + (natural? (builtin-pnum v)) + (> (builtin-pnum v) 0)))) + +;; Definicja typu wartości +(define (value? v) + (or (number? v) + (boolean? v) + (null? v) + (string? v) + (and (cons? v) + (value? (car v)) + (value? (cdr v))) + (proc? v))) + +;; Środowisko początkowe (przypisujące procedury wbudowane ich nazwom) + +(define start-env + (foldl (lambda (p env) (env-add (first p) (second p) env)) + env-empty + `((+ ,(builtin/2 +)) + (- ,(builtin/2 -)) + (* ,(builtin/2 *)) + (/ ,(builtin/2 /)) + (~ ,(builtin/1 -)) + (< ,(builtin/2 <)) + (> ,(builtin/2 >)) + (= ,(builtin/2 =)) + (<= ,(builtin/2 <=)) + (>= ,(builtin/2 >=)) + (not ,(builtin/1 not)) + (cons ,(builtin/2 cons)) + (car ,(builtin/1 car)) + (cdr ,(builtin/1 cdr)) + (pair? ,(builtin/1 cons?)) + (null? ,(builtin/1 null?)) + (boolean? ,(builtin/1 boolean?)) + (number? ,(builtin/1 number?)) + (procedure? ,(builtin/1 (lambda (x) (or (clo? x) (builtin? x))))) + (string? ,(builtin/1 string?)) + (string-= ,(builtin/2 string=?)) + ;; and so on, and so on + ))) + +;; Ewaluator +(define (eval-env e env) + (match e + [(const n) + n] + + [(var-expr x) + (env-lookup x env)] + + [(let-expr x e1 e2) + (let ((v1 (eval-env e1 env))) + (eval-env e2 (env-add x v1 env)))] + + [(letrec-expr f ef eb) + (let* ((new-env (env-add f (blackhole) env)) + (vf (eval-env ef new-env))) + (env-update! f vf new-env) + (eval-env eb new-env))] + + [(if-expr eb et ef) + (match (eval-env eb env) + [#t (eval-env et env)] + [#f (eval-env ef env)] + [v (error "Not a boolean:" v)])] + + [(lambda-expr x e) + (clo x e env)] + + [(app-expr ef ea) + (let ((vf (eval-env ef env)) + (va (eval-env ea env))) + (match vf + [(clo x e env) + (eval-env e (env-add x va env))] + [(builtin p args nm) + (if (= nm 1) + (apply p (reverse (cons va args))) + (builtin p (cons va args) (- nm 1)))] + [_ (error "Not a function:" vf)]))])) + +(define (eval e) + (eval-env e start-env)) + + +;; REPL — interpreter interaktywny (read-eval-print loop) + +;; dodajemy składnię na wiązanie zmiennych "na poziomie interpretera" +;; i komendę wyjścia "exit" ... +(struct letrec-repl (id expr)) +(struct let-repl (id expr)) +(struct exit-repl ()) + +;; ... a także rozszerzoną procedurę parsującą te dodatkowe komendy i +;; prostą obsługę błędów +(define (parse-repl q) + (with-handlers + ([exn? (lambda (exn) + (display "Parse error! ") + (displayln (exn-message exn)))]) + (cond + [(eq? q 'exit) (exit-repl)] + [(and (list? q) + (= 3 (length q)) + (eq? (first q) 'let)) + (let-repl (second q) (parse (third q)))] + [(and (list? q) + (= 3 (length q)) + (eq? (first q) 'letrec)) + (letrec-repl (second q) (parse (third q)))] + [else (parse q)]))) + +;; trochę zamieszania w procedurze eval-repl wynika z rudymentarnej +;; obsługi błędów: nie chcemy żeby błąd w interpretowanym programie +;; kończył działanie całego interpretera! +(define (eval-repl c env continue) + (define (eval-with-err e env) + (with-handlers + ([exn? (lambda (exn) + (display "Error! ") + (displayln (exn-message exn)))]) + (eval-env e env))) + (match c + [(exit-repl) + (void)] + + [(let-repl x e) + (let ((v (eval-with-err e env))) + (if (void? v) + (continue env) + (continue (env-add x v env))))] + + [(letrec-repl f e) + (let* ((new-env (env-add f (blackhole) env)) + (v (eval-with-err e new-env))) + (if (void? v) + (continue env) + (begin + (env-update! f v new-env) + (continue new-env))))] + + [_ + (let ((v (eval-with-err c env))) + (unless (void? v) + (displayln v)) + (continue env))])) + +;; I w końcu interaktywny interpreter +(define (repl) + (define (go env) + (display "FUN > ") + (let* ((q (read)) + (c (parse-repl q))) + (if (void? c) + (go env) + (eval-repl c env go)))) + (displayln "Welcome to the FUN functional language interpreter!") + (go start-env)) \ No newline at end of file diff --git a/semestr-2/racket/l9z16/solution.rkt b/semestr-2/racket/l9z16/solution.rkt new file mode 100644 index 0000000..0af169d --- /dev/null +++ b/semestr-2/racket/l9z16/solution.rkt @@ -0,0 +1,42 @@ +#lang racket + +(provide lcons lnull lnull? lcar lcdr) + + +(define (lcons x f) (mcons x f)) + +(define lnull null) + +(define lnull? null?) + +(define (lcar xs) (mcar xs)) + +(define (lcdr xs) + (let ([x (mcdr xs)]) + (cond [(not (mpair? x)) (set-mcdr! xs (x))])) + (mcdr xs)) + +(define (from n) + (lcons n (lambda () (from (+ n 1))))) + +(define nats + (from 0)) + +(define (lnth n xs) + (cond [(= n 0) (lcar xs)] + [else (lnth (- n 1) (lcdr xs))])) + +(define (lfilter p xs) + (cond [(lnull? xs) lnull] + [(p (lcar xs)) + (lcons (lcar xs) (lambda () (lfilter p (lcdr xs))))] + [else (lfilter p (lcdr xs))])) + +(define (prime? n) + (define (factors i) + (cond [(>= i n) (list n)] + [(= (modulo n i) 0) (cons i (factors (+ i 1)))] + [else (factors (+ i 1))])) + (= (length (factors 1)) 2)) + +(define primes (lfilter prime? (from 2))) \ No newline at end of file diff --git a/semestr-2/racket/l9z17/solution.rkt b/semestr-2/racket/l9z17/solution.rkt new file mode 100644 index 0000000..5e98036 --- /dev/null +++ b/semestr-2/racket/l9z17/solution.rkt @@ -0,0 +1,266 @@ +#lang racket + +; Do programming.rkt dodajemy instrukcje + +(provide eval-while parse-while env-empty env-lookup) + +;;; We współpracy z Kacprem Soleckim + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct letrec-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct cons-expr (e1 e2) #:transparent) +(struct car-expr (e) #:transparent) +(struct cdr-expr (e) #:transparent) +(struct null-expr () #:transparent) +(struct null?-expr (e) #:transparent) +(struct app (f e) #:transparent) +(struct lam (id e) #:transparent) + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n) (string? n))] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(letrec-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) + (and (expr? eb) (expr? et) (expr? ef))] + [(cons-expr e1 e2) (and (expr? e1) (expr? e2))] + [(car-expr e) (expr? e)] + [(cdr-expr e) (expr? e)] + [(null-expr) true] + [(null?-expr e) (expr? e)] + [(app f e) (and (expr? f) (expr? e))] + [(lam id e) (and (symbol? id) (expr? e))] + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (null-expr)] + [(string? q) (const q)] + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'null?)) + (null?-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'cons)) + (cons-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'car)) + (car-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'cdr)) + (cdr-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'letrec)) + (letrec-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'lambda)) + (parse-lam (second q) (third q))] + [(and (list? q) (pair? q) (not (op->proc (car q)))) + (parse-app q)] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))])) + +(define (parse-app q) + (define (parse-app-accum q acc) + (cond [(= 1 (length q)) (app acc (parse (car q)))] + [else (parse-app-accum (cdr q) (app acc (parse (car q))))])) + (parse-app-accum (cdr q) (parse (car q)))) + +(define (parse-lam pat e) + (cond [(= 1 (length pat)) + (lam (car pat) (parse e))] + [else + (lam (car pat) (parse-lam (cdr pat) e))])) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct blackhole () #:transparent) +(struct environ (xs) #:transparent) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (mcons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (mcar (car xs))) + (match (mcdr (car xs)) + [(blackhole) (error "Stuck forever in a black hole!")] + [x x])] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) +(define (env-update! x v xs) + (define (assoc-update! xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (mcar (car xs))) (set-mcdr! (car xs) v)] + [else (env-update! x v (cdr xs))])) + (assoc-update! (environ-xs xs))) +(define (env-update x v xs) ; <---------------------------------- !!! + (define (assoc-update xs) + (cond [(null? xs) (list (mcons x v))] + [(eq? x (mcar (car xs))) (cons (mcons x v) (cdr xs))] + [else (cons (car xs) (assoc-update (cdr xs)))])) + (environ (assoc-update (environ-xs xs)))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(struct clo (id e env) #:transparent) +(struct let-var (v) #:transparent) + +(define (value? v) + (or (number? v) + (boolean? v) + (string? v) + (and (pair? v) (value? (car v)) (value? (cdr v))) + (null? v) + (clo? v) + (blackhole? v))) + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))] + ['eq? eq?] + [_ false])) + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (let-var (eval-env e1 env)) env))] + [(letrec-expr x e1 e2) + (let* ([new-env (env-add x (blackhole) env)] + [v (eval-env e1 new-env)]) + (begin + (env-update! x v new-env) + (eval-env e2 new-env)))] + [(var-expr x) (let ((f (env-lookup x env))) + (if (let-var? f) (let-var-v f) f))] + [(if-expr eb et ef) (if (eval-env eb env) + (eval-env et env) + (eval-env ef env))] + [(cons-expr e1 e2) (cons (eval-env e1 env) + (eval-env e2 env))] + [(car-expr e) (car (eval-env e env))] + [(cdr-expr e) (cdr (eval-env e env))] + [(null-expr) null] + [(null?-expr e) (null? (eval-env e env))] + [(lam x e) (clo x e env)] + [(app f e) + (let ([vf (eval-env f env)] + [ve (eval-env e env)]) + (match vf [(clo x body fun-env) + (eval-env body (env-add x ve (merge-let-vars env fun-env)))]))])) + +(define (merge-let-vars env1 env2) + (define (iter xs env) + (if (null? xs) + env + (let ((cur-var (car xs))) + (if (let-var? (mcdr cur-var)) + (iter (cdr xs) (env-add (mcar cur-var) (mcdr cur-var) env)) + (iter (cdr xs) env))))) + (iter (reverse (environ-xs env2)) env1)) + +(define (eval e) (eval-env e env-empty)) + +; ---------------------------------------------------------------- !!! + +(struct skip () #:transparent) +(struct assign (x e) #:transparent) +(struct if-cmd (eb ct cf) #:transparent) +(struct while (eb cb) #:transparent) +(struct comp (c1 c2) #:transparent) + +(define (cmd? c) + (match c + [(skip) true] + [(assign x e) (and (symbol? x) (expr? e))] + [(if-cmd eb ct cf) (and (expr? eb) (cmd? ct) (cmd? cf))] + [(while eb ct) (and (expr? eb) (cmd? ct))] + [else false])) + +(define (parse-while q) + (cond + [(eq? q 'skip) (skip)] + [(null? q) (skip)] + [(and (list? q) (= (length q) 3) (eq? (second q) ':=)) + (assign (first q) + (parse (third q)))] + [(and (list? q) (= (length q) 4) (eq? (car q) 'if)) + (if-cmd (parse (second q)) + (parse-while (third q)) + (parse-while (fourth q)))] + [(and (list? q) (= (length q) 3) (eq? (car q) 'while)) + (while (parse (second q)) + (parse-while (third q)))] + [(and (list? q) (= (length q) 2)) + (comp (parse-while (first q)) + (parse-while (second q)))] + [(and (list? q) (> (length q) 2)) + (comp (parse-while (first q)) + (parse-while (cdr q)))] + [else (error "while parse error")])) + +(define (eval-while e env) + (match e + [(skip) env] + [(assign x e) + (env-update x (eval-env e env) env)] + [(if-cmd eb ct cf) + (if (eval-env eb env) + (eval-while ct env) + (eval-while cf env))] + [(while eb cb) + (if (eval-env eb env) + (eval-while e (eval-while cb env)) + env)] + [(comp c1 c2) (eval-while c2 (eval-while c1 env))])) + +; zakladamy, ze program startuje z pamiecia w ktorej +; aktwna jest zmienna t +(define WHILE_FACT + '{(i := 1) + (while (> t 0) + {(i := (* i t)) + (t := (- t 1))})}) + +(define (fact n) + (let* ([init-env (env-add 't n env-empty)] + [final-env + (eval-while (parse-while WHILE_FACT) init-env)]) + (env-lookup 'i final-env))) + +(define prog1 '{(x := 5) + (f := (let [x 50] (lambda (y) (+ x y)))) + (x := 10) + (z := (f 0))}) \ No newline at end of file diff --git a/semestr-2/racket/leftist.rkt b/semestr-2/racket/leftist.rkt new file mode 100644 index 0000000..78319e4 --- /dev/null +++ b/semestr-2/racket/leftist.rkt @@ -0,0 +1,105 @@ +#lang racket + +(provide make-elem elem-priority elem-val empty-heap heap-insert heap-merge heap-min heap-pop heap-empty?) + +(define (inc n) + (+ n 1)) + +;;; tagged lists +(define (tagged-list? len-xs tag xs) + (and (list? xs) + (= len-xs (length xs)) + (eq? (first xs) tag))) + +;;; ordered elements +(define (make-elem pri val) + (cons pri val)) + +(define (elem-priority x) + (car x)) + +(define (elem-val x) + (cdr x)) + +;;; leftist heaps (after Okasaki) + +;; data representation +(define leaf 'leaf) + +(define (leaf? h) (eq? 'leaf h)) + +(define (hnode? h) + (and (tagged-list? 5 'hnode h) + (natural? (caddr h)))) + +(define (make-hnode elem heap-a heap-b) + (if (< (rank heap-a) (rank heap-b)) + (list 'hnode elem (+ (rank heap-a) 1) heap-b heap-a) + (list 'hnode elem (+ (rank heap-b) 1) heap-a heap-b))) + +(define (hnode-elem h) + (second h)) + +(define (hnode-left h) + (fourth h)) + +(define (hnode-right h) + (fifth h)) + +(define (hnode-rank h) + (third h)) + +(define (hord? p h) + (or (leaf? h) + (<= p (elem-priority (hnode-elem h))))) + +(define (heap? h) + (or (leaf? h) + (and (hnode? h) + (heap? (hnode-left h)) + (heap? (hnode-right h)) + (<= (rank (hnode-right h)) + (rank (hnode-left h))) + (= (rank h) (inc (rank (hnode-right h)))) + (hord? (elem-priority (hnode-elem h)) + (hnode-left h)) + (hord? (elem-priority (hnode-elem h)) + (hnode-right h))))) + +(define (rank h) + (if (leaf? h) + 0 + (hnode-rank h))) + +;; operations + +(define empty-heap leaf) + +(define (heap-empty? h) + (leaf? h)) + +(define (heap-insert elt heap) + (heap-merge heap (make-hnode elt leaf leaf))) + +(define (heap-min heap) + (hnode-elem heap)) + +(define (heap-pop heap) + (heap-merge (hnode-left heap) (hnode-right heap))) + +(define (heap-merge h1 h2) + (cond + [(leaf? h1) h2] + [(leaf? h2) h1] + [else (let ((h1-min (heap-min h1)) + (h2-min (heap-min h2))) + (if (< (elem-priority h1-min) (elem-priority h2-min)) + (make-hnode h1-min (heap-merge (hnode-left h1) (hnode-right h1)) h2) + (make-hnode h2-min h1 (heap-merge (hnode-left h2) (hnode-right h2)))))])) + +;;; check that a list is sorted (useful for longish lists) +(define (sorted? xs) + (cond [(null? xs) true] + [(null? (cdr xs)) true] + [(<= (car xs) (cadr xs)) (sorted? (cdr xs))] + [else false])) diff --git a/semestr-2/racket/lista5/compiled/drracket/errortrace/prop_rkt.dep b/semestr-2/racket/lista5/compiled/drracket/errortrace/prop_rkt.dep new file mode 100644 index 0000000..6e0cfbb --- /dev/null +++ b/semestr-2/racket/lista5/compiled/drracket/errortrace/prop_rkt.dep @@ -0,0 +1 @@ +("7.6" racket ("f0a57e86828cdab35eaad454d5deb80353172518" . "8314027ed4c1c6fd9c412af77103e94790e59dd2") (collects #"errortrace" #"errortrace-key.rkt") (collects #"racket" #"main.rkt") (collects #"racket" #"runtime-config.rkt")) diff --git a/semestr-2/racket/lista5/compiled/drracket/errortrace/prop_rkt.zo b/semestr-2/racket/lista5/compiled/drracket/errortrace/prop_rkt.zo new file mode 100644 index 0000000..748fec9 Binary files /dev/null and b/semestr-2/racket/lista5/compiled/drracket/errortrace/prop_rkt.zo differ diff --git a/semestr-2/racket/lista5/compiled/drracket/errortrace/props_rkt.dep b/semestr-2/racket/lista5/compiled/drracket/errortrace/props_rkt.dep new file mode 100644 index 0000000..0926afc --- /dev/null +++ b/semestr-2/racket/lista5/compiled/drracket/errortrace/props_rkt.dep @@ -0,0 +1 @@ +("7.6" racket ("e0347fa7e89f59bc97c197db02b440f666222428" . "8314027ed4c1c6fd9c412af77103e94790e59dd2") (collects #"errortrace" #"errortrace-key.rkt") (collects #"racket" #"main.rkt") (collects #"racket" #"runtime-config.rkt")) diff --git a/semestr-2/racket/lista5/compiled/drracket/errortrace/props_rkt.zo b/semestr-2/racket/lista5/compiled/drracket/errortrace/props_rkt.zo new file mode 100644 index 0000000..eccc7f7 Binary files /dev/null and b/semestr-2/racket/lista5/compiled/drracket/errortrace/props_rkt.zo differ diff --git a/semestr-2/racket/lista5/compiled/drracket/errortrace/solution_rkt.dep b/semestr-2/racket/lista5/compiled/drracket/errortrace/solution_rkt.dep new file mode 100644 index 0000000..9810b4c --- /dev/null +++ b/semestr-2/racket/lista5/compiled/drracket/errortrace/solution_rkt.dep @@ -0,0 +1 @@ +("7.6" racket ("ae3a6974cdd4582f480927d9968aad2f495b7fc4" . "33b0c09c14dce6a2115d810ac3d0f25a9dce3205") #"C:\\Users\\franc\\Documents\\lista5\\props.rkt" (collects #"errortrace" #"errortrace-key.rkt") (collects #"racket" #"main.rkt") (collects #"racket" #"runtime-config.rkt")) diff --git a/semestr-2/racket/lista5/compiled/drracket/errortrace/solution_rkt.zo b/semestr-2/racket/lista5/compiled/drracket/errortrace/solution_rkt.zo new file mode 100644 index 0000000..ca1ab20 Binary files /dev/null and b/semestr-2/racket/lista5/compiled/drracket/errortrace/solution_rkt.zo differ diff --git a/semestr-2/racket/lista5/julita/compiled/drracket/errortrace/props_rkt.dep b/semestr-2/racket/lista5/julita/compiled/drracket/errortrace/props_rkt.dep new file mode 100644 index 0000000..0926afc --- /dev/null +++ b/semestr-2/racket/lista5/julita/compiled/drracket/errortrace/props_rkt.dep @@ -0,0 +1 @@ +("7.6" racket ("e0347fa7e89f59bc97c197db02b440f666222428" . "8314027ed4c1c6fd9c412af77103e94790e59dd2") (collects #"errortrace" #"errortrace-key.rkt") (collects #"racket" #"main.rkt") (collects #"racket" #"runtime-config.rkt")) diff --git a/semestr-2/racket/lista5/julita/compiled/drracket/errortrace/props_rkt.zo b/semestr-2/racket/lista5/julita/compiled/drracket/errortrace/props_rkt.zo new file mode 100644 index 0000000..eccc7f7 Binary files /dev/null and b/semestr-2/racket/lista5/julita/compiled/drracket/errortrace/props_rkt.zo differ diff --git a/semestr-2/racket/lista5/julita/props.rkt b/semestr-2/racket/lista5/julita/props.rkt new file mode 100644 index 0000000..204b108 --- /dev/null +++ b/semestr-2/racket/lista5/julita/props.rkt @@ -0,0 +1,52 @@ +#lang racket + +(provide conj conj-left conj-right conj? + disj disj-left disj-right disj? + neg neg-subf neg? + var?) + + +(define (conj p q) + (list 'conj p q)) + +(define (conj-left f) + (second f)) + +(define (conj-right f) + (third f)) + +(define (conj? t) + (and (list? t) + (= 3 (length t)) + (eq? 'conj (car t)))) + + +(define (disj p q) + (list 'disj p q)) + +(define (disj-left f) + (second f)) + +(define (disj-right f) + (third f)) + +(define (disj? t) + (and (list? t) + (= 3 (length t)) + (eq? 'disj (car t)))) + + +(define (neg x) + (list 'neg x)) + +(define (neg-subf x) + (second x)) + +(define (neg? t) + (and (list? t) + (= 2 (length t)) + (eq? 'neg (car t)))) + + +(define (var? t) + (symbol? t)) diff --git a/semestr-2/racket/lista5/julita/solution.bak b/semestr-2/racket/lista5/julita/solution.bak new file mode 100644 index 0000000..b3dda94 --- /dev/null +++ b/semestr-2/racket/lista5/julita/solution.bak @@ -0,0 +1,164 @@ +#lang racket + +;;Praca grupowa: +;;Dawid Holewa +;;Julita Osman +;;Aleksandra Stępniewska + +(require "props.rkt") +(provide falsifiable-cnf?) + +;Ponieważ formuła w cnf to konjunkcja klauzul +;a klauzula to alternatywa literałów +;to formuła w tej postaci jest tautologią +;wtedy i tylko wtedy gdy +;wszystkie klauzule w niej występujace sa zawsze prawdziwe (też są tautologiami) +;w przeciwnym razie, formulę taką da się zanegować; +;zatem nasz pomysł polega na tym, aby +;1)sprawdzic czy formula jest tautologia +;2)jesli tak to zwracamy fałsz +;3)wpp. pierwsza z klauzul, która nie jest tautologia +;(zatem jest mozliwa do zanegowania i jednocześnie neguje cała formułe w cnf) +;"przesuwamy" na początek listy reprezentującej cnf + +;dodatkowo to czy klauzula jest tautologią nie musimy sprawdzać wykonując wartościowanie +;możemy skorzystać z własności alternatywy +;klauzula bedzię zawsze pawdziwa tylko jeśli conajmniej jedna ze zmiennych występuje jednoczesnie ze swoją negacją + +;Falsifiable, która sprawdza każde wartościowania +;sprawdza 2^(ilosc zmiennych w całym wyrażeniu) wartosciowań, +;podczas gdy +;falsifiable, która opiera się na strukturze cnf +;przechodzi po cnf, aż do napotkania pierwszej +;mozliwej do zanegowania klauzuli +;zatem w najroszym przypadku przejdziemy po całym cnf +;ale zawsze wartosciowania negujacego formule szukamy tylko dla jedenej klauzuli +;zauważmy,ze jeśli formuła jest tautologią to oszczędzamy bardzo dużo czasu nie rozpartując wszystkich wartosciowań, tylko wypisujac odrazu falsz + +;Ta druga jest więc efektywniejsza + +(define (lit? f);; a lub ~a + (or (var? f) ;;a + (and (neg? f);;~a + (var? (neg-subf f))))) + +(define (lit-pos v) + v) + +(define (lit-neg v) + (neg v)) + +(define (lit-var l) ;;a-->a ~a-->a + (if (var? l) + l + (neg-subf l))) + +(define (lit-pos? l) + (var? l)) + +(define (to-nnf f) + (cond + [(var? f) (lit-pos f)] + [(neg? f) (to-nnf-neg (neg-subf f))] + [(conj? f) (conj (to-nnf (conj-left f)) + (to-nnf (conj-right f)))] + [(disj? f) (disj (to-nnf (disj-left f)) + (to-nnf (disj-right f)))])) + +(define (to-nnf-neg f) + (cond + [(var? f) (lit-neg f)] + [(neg? f) (to-nnf (neg-subf f))] + [(conj? f) (disj (to-nnf-neg (conj-left f)) + (to-nnf-neg (conj-right f)))] + [(disj? f) (conj (to-nnf-neg (disj-left f)) + (to-nnf-neg (disj-right f)))])) + +(define (mk-cnf xss) + (cons 'cnf xss)) + +(define (clause? f) + (and (list? f) + (andmap lit? f))) + +(define (cnf? f) + (and (pair? f) + (eq? 'cnf (car f)) + (list? (cdr f)) + (andmap clause? (cdr f)))) + +(define (to-cnf f) + (define (join xss yss) + (apply append (map (lambda (xs) (map (lambda (ys) (append xs ys)) yss)) xss))) + + (define (go f) + (cond + [(lit? f) (list (list f))] + [(conj? f) (append (go (conj-left f)) + (go (conj-right f)))] + [(disj? f) (join (go (disj-left f)) + (go (disj-right f)))])) + (mk-cnf (go f))) + + +(define (contain-both-literals? claus) + (define (aux to-check) + (cond [(empty? to-check) #f] + [(neg? (car to-check)) + (if (memq (neg-subf (car to-check)) claus) + #t + (aux (cdr to-check)))] + [else (aux (cdr to-check))])) + (aux claus)) + + +;; sprawdza czy ktorakolwiek z klauzul z listy reprezentujacej cnf +;; zawiera chociaz jedną parę zmiennej i jej negacji +;; zwraca liste pusta jesli cnf jest tautologia +;; zwraca liste z pierwsza klauzule nie bedaca tautologia "przesunieta" na poczatek (possible-to-neg) +(define (has-both big-set) + (define (possible-to-neg big-set x) ;;przesuwa x-ty element listy big-set na poczatek + (define x-ty (list-ref big-set x)) + (append (list x-ty) (remove x-ty big-set))) + (define (aux iter big-set) + (if (= iter (length big-set)) + '() + (if (contain-both-literals? (list-ref big-set iter)) ;;sprawdzamy czy iter klauzula cnf ma wystapienie a i ~a jednoczesnie + (aux (+ iter 1) big-set) + (possible-to-neg big-set iter)))) + (aux 0 (cdr big-set))) ;;(cdr big-set) bo to cnf czyli pierwszy element listy to edykieta 'cnf + + +(define (falsifiable-cnf? t) + (define tt (to-cnf (to-nnf t))) + (define f (has-both tt)) + (if (empty? f) + #f + (find-valuation f))) + + +(define (valuate f sigma) + (define (insigma-proc lista result) + (cond [(null? lista) result] + [(insigma-proc (cdr lista) (append result (list (lit-var(caar lista)))))])) + ;; insigma ---> lista zmiennych z wartosciowania pierwszej klauzuli: + (define insigma (insigma-proc sigma '())) + (define (aux insigma otherclause sigma) + (cond [(null? otherclause) sigma] + [(if (memq (lit-var (car otherclause)) insigma) + (aux insigma (cdr otherclause) sigma) + (if(neg? (car otherclause)) + (aux (append insigma (list(car otherclause))) + (cdr otherclause) + (append sigma (list(list (lit-var(car otherclause)) 1)))) + (aux (append insigma (list(car otherclause))) + (cdr otherclause) + (append sigma (list(list (car otherclause) 0))))))])) + (if (empty? f) + sigma + (valuate (cdr f) + (aux insigma (car f) sigma)))) + +(define (find-valuation f) + (valuate f '())) + diff --git a/semestr-2/racket/lista5/julita/solution.rkt b/semestr-2/racket/lista5/julita/solution.rkt new file mode 100644 index 0000000..da87bf9 --- /dev/null +++ b/semestr-2/racket/lista5/julita/solution.rkt @@ -0,0 +1,164 @@ +#lang racket + +;;Praca grupowa: +;;Dawid Holewa +;;Julita Osman +;;Aleksandra Stępniewska + +(require "props.rkt") +(provide falsifiable-cnf?) + +;Ponieważ formuła w cnf to konjunkcja klauzul +;a klauzula to alternatywa literałów +;to formuła w tej postaci jest tautologią +;wtedy i tylko wtedy gdy +;wszystkie klauzule w niej występujace sa zawsze prawdziwe (też są tautologiami) +;w przeciwnym razie, formulę taką da się zanegować; +;zatem nasz pomysł polega na tym, aby +;1)sprawdzic czy formula jest tautologia +;2)jesli tak to zwracamy fałsz +;3)wpp. pierwsza z klauzul, która nie jest tautologia +;(zatem jest mozliwa do zanegowania i jednocześnie neguje cała formułe w cnf) +;"przesuwamy" na początek listy reprezentującej cnf + +;dodatkowo to czy klauzula jest tautologią nie musimy sprawdzać wykonując wartościowanie +;możemy skorzystać z własności alternatywy +;klauzula bedzię zawsze pawdziwa tylko jeśli conajmniej jedna ze zmiennych występuje jednoczesnie ze swoją negacją + +;Falsifiable, która sprawdza każde wartościowania +;sprawdza 2^(ilosc zmiennych w całym wyrażeniu) wartosciowań, +;podczas gdy +;falsifiable, która opiera się na strukturze cnf +;przechodzi po cnf, aż do napotkania pierwszej +;mozliwej do zanegowania klauzuli +;zatem w najroszym przypadku przejdziemy po całym cnf +;ale zawsze wartosciowania negujacego formule szukamy tylko dla jedenej klauzuli +;zauważmy,ze jeśli formuła jest tautologią to oszczędzamy bardzo dużo czasu nie rozpartując wszystkich wartosciowań, tylko wypisujac odrazu falsz + +;Ta druga jest więc efektywniejsza + +(define (lit? f);; a lub ~a + (or (var? f) ;;a + (and (neg? f);;~a + (var? (neg-subf f))))) + +(define (lit-pos v) + v) + +(define (lit-neg v) + (neg v)) + +(define (lit-var l) ;;a-->a ~a-->a + (if (var? l) + l + (neg-subf l))) + +(define (lit-pos? l) + (var? l)) + +(define (to-nnf f) + (cond + [(var? f) (lit-pos f)] + [(neg? f) (to-nnf-neg (neg-subf f))] + [(conj? f) (conj (to-nnf (conj-left f)) + (to-nnf (conj-right f)))] + [(disj? f) (disj (to-nnf (disj-left f)) + (to-nnf (disj-right f)))])) + +(define (to-nnf-neg f) + (cond + [(var? f) (lit-neg f)] + [(neg? f) (to-nnf (neg-subf f))] + [(conj? f) (disj (to-nnf-neg (conj-left f)) + (to-nnf-neg (conj-right f)))] + [(disj? f) (conj (to-nnf-neg (disj-left f)) + (to-nnf-neg (disj-right f)))])) + +(define (mk-cnf xss) + (cons 'cnf xss)) + +(define (clause? f) + (and (list? f) + (andmap lit? f))) + +(define (cnf? f) + (and (pair? f) + (eq? 'cnf (car f)) + (list? (cdr f)) + (andmap clause? (cdr f)))) + +(define (to-cnf f) + (define (join xss yss) + (apply append (map (lambda (xs) (map (lambda (ys) (append xs ys)) yss)) xss))) + + (define (go f) + (cond + [(lit? f) (list (list f))] + [(conj? f) (append (go (conj-left f)) + (go (conj-right f)))] + [(disj? f) (join (go (disj-left f)) + (go (disj-right f)))])) + (mk-cnf (go f))) + + +(define (contain-both-literals? claus) + (define (aux to-check) + (cond [(empty? to-check) #f] + [(neg? (car to-check)) + (if (memq (neg-subf (car to-check)) claus) + #t + (aux (cdr to-check)))] + [else (aux (cdr to-check))])) + (aux claus)) + + +;; sprawdza czy ktorakolwiek z klauzul z listy reprezentujacej cnf +;; zawiera chociaz jedną parę zmiennej i jej negacji +;; zwraca liste pusta jesli cnf jest tautologia +;; zwraca liste z pierwsza klauzule nie bedaca tautologia "przesunieta" na poczatek (possible-to-neg) +(define (has-both big-set) + (define (possible-to-neg big-set x) ;;przesuwa x-ty element listy big-set na poczatek + (define x-ty (list-ref big-set x)) + (append (list x-ty) (remove x-ty big-set))) + (define (aux iter big-set) + (if (= iter (length big-set)) + '() + (if (contain-both-literals? (list-ref big-set iter)) ;;sprawdzamy czy iter klauzula cnf ma wystapienie a i ~a jednoczesnie + (aux (+ iter 1) big-set) + (possible-to-neg big-set iter)))) + (aux 0 (cdr big-set))) ;;(cdr big-set) bo to cnf czyli pierwszy element listy to edykieta 'cnf + + +(define (falsifiable-cnf? t) + (define tt (to-cnf (to-nnf t))) + (define f (has-both tt)) + (if (empty? f) + #f + (find-valuation f))) + + +(define (valuate f sigma) + (define (insigma-proc lista result) + (cond [(null? lista) result] + [(insigma-proc (cdr lista) (append result (list (lit-var(caar lista)))))])) + ;; insigma ---> lista zmiennych z wartosciowania pierwszej klauzuli: + (define insigma (insigma-proc sigma '())) + (define (aux insigma otherclause sigma) + (cond [(null? otherclause) sigma] + [(if (memq (lit-var (car otherclause)) insigma) + (aux insigma (cdr otherclause) sigma) + (if(neg? (car otherclause)) + (aux (append insigma (list(car otherclause))) + (cdr otherclause) + (append sigma (list(list (lit-var(car otherclause)) true)))) + (aux (append insigma (list(car otherclause))) + (cdr otherclause) + (append sigma (list(list (car otherclause) false))))))])) + (if (empty? f) + sigma + (valuate (cdr f) + (aux insigma (car f) sigma)))) + +(define (find-valuation f) + (valuate f '())) + diff --git a/semestr-2/racket/lista5/prop.rkt b/semestr-2/racket/lista5/prop.rkt new file mode 100644 index 0000000..6f1f7b4 --- /dev/null +++ b/semestr-2/racket/lista5/prop.rkt @@ -0,0 +1 @@ +#lang racket diff --git a/semestr-2/racket/lista5/props.bak b/semestr-2/racket/lista5/props.bak new file mode 100644 index 0000000..1a5659a --- /dev/null +++ b/semestr-2/racket/lista5/props.bak @@ -0,0 +1,71 @@ +#lang racket + +(provide var? + neg? + conj? + disj? + conj + disj + neg + conj-left + conj-right + disj-right + disj-left + neg-subf) +; (require "solution.rkt") + +(define (var? t) (symbol? t)) + +(define (neg? t) + (and (list? t) + (= 2 (length t)) + (eq? 'neg (car t)))) + +(define (conj? t) + (and (list? t) + (= 3 (length t)) + (eq? 'conj (car t)))) + +(define (disj? t) + (and (list? t) + (= 3 (length t)) + (eq? 'disj (car t)))) + +(define (lit? t) + (or (var? t) + (and (neg? t) + (var? (neg-subf t))))) + +(define (conj left right) + (list 'conj left right)) + +(define (disj left right) + (list 'disj left right)) + +(define (neg f) + (list 'neg f)) + +(define (conj-left f) + (if (conj? f) + (cadr f) + (error "Złe dane ze znacznikiem -- CONJ-LEFT" f))) + +(define (conj-right f) + (if (conj? f) + (caddr f) + (error "Złe dane ze znacznikiem -- CONJ-RIGHT" f))) + +(define (disj-left f) + (if (disj? f) + (cadr f) + (error "Złe dane ze znacznikiem -- DISJ-LEFT" f))) + +(define (disj-right f) + (if (disj? f) + (caddr f) + (error "Złe dane ze znacznikiem -- DISJ-RIGHT" f))) + +(define (neg-subf f) + (if (neg? f) + (cadr f) + (error "Złe dane ze znacznikiem -- NEG-FORM" f))) diff --git a/semestr-2/racket/lista5/props.rkt b/semestr-2/racket/lista5/props.rkt new file mode 100644 index 0000000..204b108 --- /dev/null +++ b/semestr-2/racket/lista5/props.rkt @@ -0,0 +1,52 @@ +#lang racket + +(provide conj conj-left conj-right conj? + disj disj-left disj-right disj? + neg neg-subf neg? + var?) + + +(define (conj p q) + (list 'conj p q)) + +(define (conj-left f) + (second f)) + +(define (conj-right f) + (third f)) + +(define (conj? t) + (and (list? t) + (= 3 (length t)) + (eq? 'conj (car t)))) + + +(define (disj p q) + (list 'disj p q)) + +(define (disj-left f) + (second f)) + +(define (disj-right f) + (third f)) + +(define (disj? t) + (and (list? t) + (= 3 (length t)) + (eq? 'disj (car t)))) + + +(define (neg x) + (list 'neg x)) + +(define (neg-subf x) + (second x)) + +(define (neg? t) + (and (list? t) + (= 2 (length t)) + (eq? 'neg (car t)))) + + +(define (var? t) + (symbol? t)) diff --git a/semestr-2/racket/lista5/skrr/solution.bak b/semestr-2/racket/lista5/skrr/solution.bak new file mode 100644 index 0000000..72c7f36 --- /dev/null +++ b/semestr-2/racket/lista5/skrr/solution.bak @@ -0,0 +1,135 @@ +#lang racket + +(provide falsifiable-cnf?) +(require "props.rkt") + +(define (prop? f) + (or (var? f) + (and (neg? f) + (prop? (neg-subf f))) + (and (disj? f) + (prop? (disj-left f)) + (prop? (disj-right f))) + (and (conj? f) + (prop? (conj-left f)) + (prop? (conj-right f))))) + +(define (lit-var f) + (cond [(var? f) f] + [(neg? f) (neg-subf f)] + [else (error "Złe dane ze znacznikiem -- LIT-VAR" f)])) + +(define (free-vars f) + (cond [(null? f) null] + [(var? f) (list f)] + [(neg? f) (free-vars (neg-subf f))] + [(conj? f) (append (free-vars (conj-left f)) + (free-vars (conj-right f)))] + [(disj? f) (append (free-vars (disj-left f)) + (free-vars (disj-right f)))] + [else (error "Zła formula -- FREE-VARS" f)])) + +(define (gen-vals xs) + (if (null? xs) + (list null) + (let* + ((vss (gen-vals (cdr xs))) + (x (car xs)) + (vst (map (λ (vs) (cons (list x true) vs)) vss)) + (vsf (map (λ (vs) (cons (list x false) vs)) vss))) + (append vst vsf)))) + +(define (eval-formula f evaluation) + (cond [(var? f) + (let ((val (assoc f evaluation))) + (if (not val) + (error "Zmienna wolna nie wystepuje w wartościowaniu -- EVAL-FORMULA" f evaluation) + (cadr val)))] + [(neg? f) (not (eval-formula (neg-subf f) evaluation))] + [(disj? f) (or (eval-formula (disj-left f) evaluation) + (eval-formula (disj-right f) evaluation))] + [(conj? f) (and (eval-formula (conj-left f) evaluation) + (eval-formula (conj-right f) evaluation))] + [else (error "Zła formuła -- EVAL-FORMULA" f evaluation)])) + +(define (falsifiable-eval? f) + (let* ((evaluations (gen-vals (free-vars f))) + (results (map (λ (evaluation) (eval-formula f evaluation)) evaluations))) + (ormap false? results))) + +(define (nff? f) + (cond [(lit? f) true] + [(neg? f) false] + [(conj? f) (and (nff? (conj-left f)) + (nff? (conj-right f)))] + [(disj? f) (and (nff? (disj-left f)) + (nff? (disj-right f)))] + [else (error "Zła formuła -- NFF?" f)])) + +(define (convert-to-nnf f) + (cond [(lit? f) f] + [(neg? f) (convert-negation (neg-subf f))] + [(conj? f) (conj (convert-to-nnf (conj-left f)) + (convert-to-nnf (conj-right f)))] + [(disj? f) (disj (convert-to-nnf (disj-left f)) + (convert-to-nnf (disj-right f)))] + [else (error "Zła formuła -- CONVERT" f)])) + +(define (convert-negation f) + (cond [(lit? f) + (if (var? f) + (neg f) + (neg-subf f))] + [(neg? f) (convert-to-nnf (neg-subf f))] + [(conj? f) (disj (convert-negation (conj-left f)) + (convert-negation (conj-right f)))] + [(disj? f) (conj (convert-negation (disj-left f)) + (convert-negation (disj-right f)))] + [else (error "Zła formuła -- CONVERT-NEGATION" f)])) + +(define (clause? x) + (and (list? x) + (andmap lit? x))) + +(define (clause-empty? x) + (and (clause? x) + (null? x))) + +(define (cnf? x) + (and (list? x) + (andmap clause? x))) + +(define (flatmap proc seq) + (foldl append null (map proc seq))) + +(define (convert-to-cnf f) + (define (convert f) + (cond [(lit? f) (list (list f))] + [(conj? f) (append (convert-to-cnf (conj-left f)) + (convert-to-cnf (conj-right f)))] + [(disj? f) + (let ((clause-left (convert-to-cnf (disj-left f))) + (clause-right (convert-to-cnf (disj-right f)))) + (flatmap (λ (clause) + (map (λ (clause2) + (append clause2 clause)) clause-left)) + clause-right))])) + (convert (convert-to-nnf f))) + +(define (falsifiable-clause? clause) + (cond [(clause-empty? clause) true] + [(lit? (findf (λ (l) (equal? + l + (convert-to-nnf (neg (car clause))))) + clause)) false] + [else (falsifiable-clause? (cdr clause))])) + +(define (falsifiable-cnf? f) + (define (neg-value lit) + (if (var? lit) + (list lit false) + (list (neg-subf lit) true))) + (ormap (λ (clause) (if (falsifiable-clause? clause) + (map neg-value clause) + false)) + (convert-to-cnf f))) \ No newline at end of file diff --git a/semestr-2/racket/lista5/skrr/solution.rkt b/semestr-2/racket/lista5/skrr/solution.rkt new file mode 100644 index 0000000..e8efbc9 --- /dev/null +++ b/semestr-2/racket/lista5/skrr/solution.rkt @@ -0,0 +1,88 @@ +#lang racket + +(require "props.rkt") +(provide falsifiable-cnf?) + +(define (lit? f) + (or (var? f) + (and (neg? f) + (var? (neg-subf f))))) + +(define (lit-pos v) + v) + +(define (lit-neg v) + (neg v)) + +(define (lit-var l) + (if (var? l) + l + (neg-subf l))) + +(define (lit-pos? l) + (var? l)) + +(define (to-nnf f) + (cond + [(var? f) (lit-pos f)] + [(neg? f) (to-nnf-neg (neg-subf f))] + [(conj? f) (conj (to-nnf (conj-left f)) + (to-nnf (conj-right f)))] + [(disj? f) (disj (to-nnf (disj-left f)) + (to-nnf (disj-right f)))])) + +(define (to-nnf-neg f) + (cond + [(var? f) (lit-neg f)] + [(neg? f) (to-nnf (neg-subf f))] + [(conj? f) (disj (to-nnf-neg (conj-left f)) + (to-nnf-neg (conj-right f)))] + [(disj? f) (conj (to-nnf-neg (disj-left f)) + (to-nnf-neg (disj-right f)))])) + +(define (mk-cnf xss) + (cons 'cnf xss)) + +(define (clause? f) + (and (list? f) + (andmap lit? f))) + +(define (cnf? f) + (and (pair? f) + (eq? 'cnf (car f)) + (list? (cdr f)) + (andmap clause? (cdr f)))) + +(define (to-cnf f) + (define (join xss yss) + (apply append (map (lambda (xs) (map (lambda (ys) (append xs ys)) yss)) xss))) + (define (go f) + (cond + [(lit? f) (list (list f))] + [(conj? f) (append (go (conj-left f)) + (go (conj-right f)))] + [(disj? f) (join (go (disj-left f)) + (go (disj-right f)))])) + (mk-cnf (go f))) + +(define (clause-empty? x) + (and (clause? x) + (null? x))) + +(define (falsifiable-clause? clause) + (cond [(clause-empty? clause) true] + [(lit? (findf (λ (l) (equal? + l + (to-nnf (neg (car clause))))) + clause)) false] + [else (falsifiable-clause? (cdr clause))])) + +(define (falsifiable-cnf? f) + (define (neg-value lit) + (if (var? lit) + (list lit false) + (list (neg-subf lit) true))) + (ormap (λ (clause) (if (falsifiable-clause? clause) + (map neg-value clause) + false)) + (convert-to-cnf f))) \ No newline at end of file diff --git a/semestr-2/racket/lista5/sol2.rkt b/semestr-2/racket/lista5/sol2.rkt new file mode 100644 index 0000000..d037472 --- /dev/null +++ b/semestr-2/racket/lista5/sol2.rkt @@ -0,0 +1,90 @@ +#lang racket +(provide falsifiable-cnf?) (require "props.rkt") + + +(define (falsifiable-cnf? p) + ;literał + (define (lit? p) + (or (var? p) + (and (neg? p) (var? (neg-subf p))) + )) + + (define (lit-pos? p) + (if (lit? p) + (var? p) + (error "not a literal" p) + )) + + (define (lit-var p) + (cond + [(not (lit? p)) (error "not a literal" p)] + [(lit-pos? p) p] + [else (neg-subf p)] + )) + + (define (contr p) + (if (lit? p) + (if (neg? p) (neg-subf p) (neg p)) + (error "not a literal" p) + )) + + ;konwertowanie + (define (convert-to-cnf p) + (define (convert-to-nnf p) + (cond + [(lit? p) p] + [(and (neg? p) (conj? (neg-subf p))) + (let ((A (neg-subf p))) + (disj (convert-to-nnf (neg (conj-left A))) (convert-to-nnf (neg (conj-right A)))))] + [(and (neg? p) (disj? (neg-subf p))) + (let ((A (neg-subf p))) + (conj (convert-to-nnf (neg (disj-left A))) (convert-to-nnf (neg (disj-right A)))))] + [(and (neg? p) (neg? (neg-subf p))) (convert-to-nnf (neg-subf (neg-subf p)))] + [(conj? p) (conj (convert-to-nnf (conj-right p)) (convert-to-nnf (conj-left p)))] + [(disj? p) (disj (convert-to-nnf (disj-right p)) (convert-to-nnf (disj-left p)))] + [else (error "not a proposition" p)])) + + (define (flatmap proc seq) + (foldr append null (map proc seq))) + + (define (merge a b) + (flatmap (lambda (c) (map (lambda (c2) (append c c2)) b)) a)) + + (define (convert p) + (cond + [(lit? p) (list (list p))] + [(conj? p) (append (convert (conj-left p)) (convert (conj-right p)))] + [(disj? p) (let* ((L (convert (disj-left p))) (R (convert (disj-right p)))) + (merge L R))] + [else (error "it should never be here" p)] + )) + + (map (lambda (c) (remove-duplicates c)) (convert (convert-to-nnf p)))) + + ;prawdziwa funkcja + (define cnf (convert-to-cnf p)) + + (define (falsifiable-clause? c) + (cond + [(null? c) #t] + [(eq? #f (member (contr (car c)) c)) (falsifiable-clause? (cdr c))] + [else #f] + )) + + (define (falsified-clause c) + (if (null? c) + null + (cons (list (lit-var (car c)) (not (lit-pos? (car c)))) (falsified-clause (cdr c))) + )) + + (define (falsified-val p) + (cond + [(null? p) false] + [(falsifiable-clause? (car p)) (falsified-clause (car p))] + [else (falsified-val (cdr p))] + ) + ) + (falsified-val cnf)) + + +;złożoność wykładnicza tak jak falsible-eval ale często w praktyce szybsza jak nie ma za dużo alternatyw. \ No newline at end of file diff --git a/semestr-2/racket/lista5/solution.bak b/semestr-2/racket/lista5/solution.bak new file mode 100644 index 0000000..72c7f36 --- /dev/null +++ b/semestr-2/racket/lista5/solution.bak @@ -0,0 +1,135 @@ +#lang racket + +(provide falsifiable-cnf?) +(require "props.rkt") + +(define (prop? f) + (or (var? f) + (and (neg? f) + (prop? (neg-subf f))) + (and (disj? f) + (prop? (disj-left f)) + (prop? (disj-right f))) + (and (conj? f) + (prop? (conj-left f)) + (prop? (conj-right f))))) + +(define (lit-var f) + (cond [(var? f) f] + [(neg? f) (neg-subf f)] + [else (error "Złe dane ze znacznikiem -- LIT-VAR" f)])) + +(define (free-vars f) + (cond [(null? f) null] + [(var? f) (list f)] + [(neg? f) (free-vars (neg-subf f))] + [(conj? f) (append (free-vars (conj-left f)) + (free-vars (conj-right f)))] + [(disj? f) (append (free-vars (disj-left f)) + (free-vars (disj-right f)))] + [else (error "Zła formula -- FREE-VARS" f)])) + +(define (gen-vals xs) + (if (null? xs) + (list null) + (let* + ((vss (gen-vals (cdr xs))) + (x (car xs)) + (vst (map (λ (vs) (cons (list x true) vs)) vss)) + (vsf (map (λ (vs) (cons (list x false) vs)) vss))) + (append vst vsf)))) + +(define (eval-formula f evaluation) + (cond [(var? f) + (let ((val (assoc f evaluation))) + (if (not val) + (error "Zmienna wolna nie wystepuje w wartościowaniu -- EVAL-FORMULA" f evaluation) + (cadr val)))] + [(neg? f) (not (eval-formula (neg-subf f) evaluation))] + [(disj? f) (or (eval-formula (disj-left f) evaluation) + (eval-formula (disj-right f) evaluation))] + [(conj? f) (and (eval-formula (conj-left f) evaluation) + (eval-formula (conj-right f) evaluation))] + [else (error "Zła formuła -- EVAL-FORMULA" f evaluation)])) + +(define (falsifiable-eval? f) + (let* ((evaluations (gen-vals (free-vars f))) + (results (map (λ (evaluation) (eval-formula f evaluation)) evaluations))) + (ormap false? results))) + +(define (nff? f) + (cond [(lit? f) true] + [(neg? f) false] + [(conj? f) (and (nff? (conj-left f)) + (nff? (conj-right f)))] + [(disj? f) (and (nff? (disj-left f)) + (nff? (disj-right f)))] + [else (error "Zła formuła -- NFF?" f)])) + +(define (convert-to-nnf f) + (cond [(lit? f) f] + [(neg? f) (convert-negation (neg-subf f))] + [(conj? f) (conj (convert-to-nnf (conj-left f)) + (convert-to-nnf (conj-right f)))] + [(disj? f) (disj (convert-to-nnf (disj-left f)) + (convert-to-nnf (disj-right f)))] + [else (error "Zła formuła -- CONVERT" f)])) + +(define (convert-negation f) + (cond [(lit? f) + (if (var? f) + (neg f) + (neg-subf f))] + [(neg? f) (convert-to-nnf (neg-subf f))] + [(conj? f) (disj (convert-negation (conj-left f)) + (convert-negation (conj-right f)))] + [(disj? f) (conj (convert-negation (disj-left f)) + (convert-negation (disj-right f)))] + [else (error "Zła formuła -- CONVERT-NEGATION" f)])) + +(define (clause? x) + (and (list? x) + (andmap lit? x))) + +(define (clause-empty? x) + (and (clause? x) + (null? x))) + +(define (cnf? x) + (and (list? x) + (andmap clause? x))) + +(define (flatmap proc seq) + (foldl append null (map proc seq))) + +(define (convert-to-cnf f) + (define (convert f) + (cond [(lit? f) (list (list f))] + [(conj? f) (append (convert-to-cnf (conj-left f)) + (convert-to-cnf (conj-right f)))] + [(disj? f) + (let ((clause-left (convert-to-cnf (disj-left f))) + (clause-right (convert-to-cnf (disj-right f)))) + (flatmap (λ (clause) + (map (λ (clause2) + (append clause2 clause)) clause-left)) + clause-right))])) + (convert (convert-to-nnf f))) + +(define (falsifiable-clause? clause) + (cond [(clause-empty? clause) true] + [(lit? (findf (λ (l) (equal? + l + (convert-to-nnf (neg (car clause))))) + clause)) false] + [else (falsifiable-clause? (cdr clause))])) + +(define (falsifiable-cnf? f) + (define (neg-value lit) + (if (var? lit) + (list lit false) + (list (neg-subf lit) true))) + (ormap (λ (clause) (if (falsifiable-clause? clause) + (map neg-value clause) + false)) + (convert-to-cnf f))) \ No newline at end of file diff --git a/semestr-2/racket/lista5/solution.rkt b/semestr-2/racket/lista5/solution.rkt new file mode 100644 index 0000000..67964d8 --- /dev/null +++ b/semestr-2/racket/lista5/solution.rkt @@ -0,0 +1,140 @@ +#lang racket + +(provide falsifiable-cnf?) +(require "props.rkt") + +(define (prop? f) + (or (var? f) + (and (neg? f) + (prop? (neg-subf f))) + (and (disj? f) + (prop? (disj-left f)) + (prop? (disj-right f))) + (and (conj? f) + (prop? (conj-left f)) + (prop? (conj-right f))))) + +(define (lit? t) + (or (var? t) + (and (neg? t) + (var? (neg-subf t))))) + +(define (lit-var f) + (cond [(var? f) f] + [(neg? f) (neg-subf f)] + [else (error "Złe dane ze znacznikiem -- LIT-VAR" f)])) + +(define (free-vars f) + (cond [(null? f) null] + [(var? f) (list f)] + [(neg? f) (free-vars (neg-subf f))] + [(conj? f) (append (free-vars (conj-left f)) + (free-vars (conj-right f)))] + [(disj? f) (append (free-vars (disj-left f)) + (free-vars (disj-right f)))] + [else (error "Zła formula -- FREE-VARS" f)])) + +(define (gen-vals xs) + (if (null? xs) + (list null) + (let* + ((vss (gen-vals (cdr xs))) + (x (car xs)) + (vst (map (λ (vs) (cons (list x true) vs)) vss)) + (vsf (map (λ (vs) (cons (list x false) vs)) vss))) + (append vst vsf)))) + +(define (eval-formula f evaluation) + (cond [(var? f) + (let ((val (assoc f evaluation))) + (if (not val) + (error "Zmienna wolna nie wystepuje w wartościowaniu -- EVAL-FORMULA" f evaluation) + (cadr val)))] + [(neg? f) (not (eval-formula (neg-subf f) evaluation))] + [(disj? f) (or (eval-formula (disj-left f) evaluation) + (eval-formula (disj-right f) evaluation))] + [(conj? f) (and (eval-formula (conj-left f) evaluation) + (eval-formula (conj-right f) evaluation))] + [else (error "Zła formuła -- EVAL-FORMULA" f evaluation)])) + +(define (falsifiable-eval? f) + (let* ((evaluations (gen-vals (free-vars f))) + (results (map (λ (evaluation) (eval-formula f evaluation)) evaluations))) + (ormap false? results))) + +(define (nff? f) + (cond [(lit? f) true] + [(neg? f) false] + [(conj? f) (and (nff? (conj-left f)) + (nff? (conj-right f)))] + [(disj? f) (and (nff? (disj-left f)) + (nff? (disj-right f)))] + [else (error "Zła formuła -- NFF?" f)])) + +(define (convert-to-nnf f) + (cond [(lit? f) f] + [(neg? f) (convert-negation (neg-subf f))] + [(conj? f) (conj (convert-to-nnf (conj-left f)) + (convert-to-nnf (conj-right f)))] + [(disj? f) (disj (convert-to-nnf (disj-left f)) + (convert-to-nnf (disj-right f)))] + [else (error "Zła formuła -- CONVERT" f)])) + +(define (convert-negation f) + (cond [(lit? f) + (if (var? f) + (neg f) + (neg-subf f))] + [(neg? f) (convert-to-nnf (neg-subf f))] + [(conj? f) (disj (convert-negation (conj-left f)) + (convert-negation (conj-right f)))] + [(disj? f) (conj (convert-negation (disj-left f)) + (convert-negation (disj-right f)))] + [else (error "Zła formuła -- CONVERT-NEGATION" f)])) + +(define (clause? x) + (and (list? x) + (andmap lit? x))) + +(define (clause-empty? x) + (and (clause? x) + (null? x))) + +(define (cnf? x) + (and (list? x) + (andmap clause? x))) + +(define (flatmap proc seq) + (foldl append null (map proc seq))) + +(define (convert-to-cnf f) + (define (convert f) + (cond [(lit? f) (list (list f))] + [(conj? f) (append (convert-to-cnf (conj-left f)) + (convert-to-cnf (conj-right f)))] + [(disj? f) + (let ((clause-left (convert-to-cnf (disj-left f))) + (clause-right (convert-to-cnf (disj-right f)))) + (flatmap (λ (clause) + (map (λ (clause2) + (append clause2 clause)) clause-left)) + clause-right))])) + (map (lambda (clause) (remove-duplicates clause)) (convert (convert-to-nnf f)))) + +(define (falsifiable-clause? clause) + (cond [(clause-empty? clause) true] + [(lit? (findf (λ (l) (equal? + l + (convert-to-nnf (neg (car clause))))) + clause)) false] + [else (falsifiable-clause? (cdr clause))])) + +(define (falsifiable-cnf? f) + (define (neg-value lit) + (if (var? lit) + (list lit false) + (list (neg-subf lit) true))) + (ormap (λ (clause) (if (falsifiable-clause? clause) + (map neg-value clause) + false)) + (convert-to-cnf f))) \ No newline at end of file diff --git a/semestr-2/racket/lista5/xd.bak b/semestr-2/racket/lista5/xd.bak new file mode 100644 index 0000000..d814e10 --- /dev/null +++ b/semestr-2/racket/lista5/xd.bak @@ -0,0 +1,4 @@ +#lang racket + +(require "solution.rkt") + diff --git a/semestr-2/racket/lista5/xd.rkt b/semestr-2/racket/lista5/xd.rkt new file mode 100644 index 0000000..64ce78c --- /dev/null +++ b/semestr-2/racket/lista5/xd.rkt @@ -0,0 +1,4 @@ +#lang racket + +(require "solution.rkt") +(require "props.rkt") diff --git a/semestr-2/racket/lista6/lista8/kappa.py b/semestr-2/racket/lista6/lista8/kappa.py new file mode 100644 index 0000000..f359d5c --- /dev/null +++ b/semestr-2/racket/lista6/lista8/kappa.py @@ -0,0 +1,13 @@ +import pylab + +a = int(input("podaj liczbe: ")) +b = int(input("podaj liczbe: ")) + +x = range(-10, 11) +y = [] +for i in x: + y.append(a * i + b) +pylab.plot(x, y) +pylab.title('Wykres f(x) = a*x - b') +pylab.grid(True) +pylab.show() diff --git a/semestr-2/racket/lista6/lista8/zad1.bak b/semestr-2/racket/lista6/lista8/zad1.bak new file mode 100644 index 0000000..0960f21 --- /dev/null +++ b/semestr-2/racket/lista6/lista8/zad1.bak @@ -0,0 +1,98 @@ +#lang racket + +; Do let-env.rkt dodajemy wartosci boolowskie +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] ; <----------------- !!! + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) ; <--------------------------------------- !!! + (and (expr? eb) (expr? et) (expr? ef))] + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] ; <---------------------------- !!! + [(eq? q 'false) (const false)] ; <---------------------------- !!! + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) ; <--- !!! + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))])) + +(define (test-parse) (parse '(let [x (+ 2 2)] (+ x 1)))) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs)) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(define (value? v) + (or (number? v) (boolean? v))) + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] ; <----------- !!! + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))])) + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) ; <----------------- !!! + (eval-env et env) + (eval-env ef env))])) + +(define (eval e) (eval-env e env-empty)) + +(define program + '(if (or (< (% 123 10) 5) + true) + (+ 2 3) + (/ 2 0))) + +(define (test-eval) (eval (parse program))) \ No newline at end of file diff --git a/semestr-2/racket/lista6/lista8/zad1.rkt b/semestr-2/racket/lista6/lista8/zad1.rkt new file mode 100644 index 0000000..1cd6b0b --- /dev/null +++ b/semestr-2/racket/lista6/lista8/zad1.rkt @@ -0,0 +1,104 @@ +#lang racket + +; Do let-env.rkt dodajemy wartosci boolowskie +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] ; <----------------- !!! + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) ; <--------------------------------------- !!! + (and (expr? eb) (expr? et) (expr? ef))] + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] ; <---------------------------- !!! + [(eq? q 'false) (const false)] ; <---------------------------- !!! + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) ; <--- !!! + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'and)) + (if-expr (parse (second q)) + (parse (third q)) + (const false))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'or)) + (if-expr (parse (second q)) + (const true) + (parse (third q)))] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))])) + +(define (test-parse) (parse '(let [x (+ 2 2)] (+ x 1)))) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs)) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(define (value? v) + (or (number? v) (boolean? v))) + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] ; <----------- !!! + ['= =] ['> >] ['>= >=] ['< <] ['<= <=])) + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) ; <----------------- !!! + (eval-env et env) + (eval-env ef env))])) + +(define (eval e) (eval-env e env-empty)) + +(define program + '(if (or (< (% 123 10) 5) + true) + (+ 2 3) + (/ 2 0))) + +(define (test-eval) (eval (parse program))) \ No newline at end of file diff --git a/semestr-2/racket/lista6/lista8/zad4.bak b/semestr-2/racket/lista6/lista8/zad4.bak new file mode 100644 index 0000000..503099d --- /dev/null +++ b/semestr-2/racket/lista6/lista8/zad4.bak @@ -0,0 +1,114 @@ +#lang racket + +; Do boolean.rkt dodajemy pary +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct cons-expr (e1 e2) #:transparent) ; <------------------- !!! +(struct car-expr (e) #:transparent) ; <------------------- !!! +(struct cdr-expr (e) #:transparent) ; <------------------- !!! + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) + (and (expr? eb) (expr? et) (expr? ef))] + [(cons-expr e1 e2) (and (expr? e1) (expr? e2))] ; <----------- !!! + [(car-expr e) (expr? e)] ; <---------------------------------- !!! + [(cdr-expr e) (expr? e)] ; <---------------------------------- !!! + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'cons)) ; <- !!! + (cons-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'car)) ; <-- !!! + (car-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'cdr)) ; <-- !!! + (cdr-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))])) + +(define (test-parse) (parse '(let [x (+ 2 2)] (+ x 1)))) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs)) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(define (value? v) + (or (number? v) + (boolean? v) + (and (pair? v) (value? (car v)) (value? (cdr v))))) + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))])) + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) + (eval-env et env) + (eval-env ef env))] + [(cons-expr e1 e2) (cons (eval-env e1 env) ; <---------------- !!! + (eval-env e2 env))] + [(car-expr e) (car (eval-env e env))] ; <--------------------- !!! + [(cdr-expr e) (cdr (eval-env e env))])) ; <------------------- !!! + +(define (eval e) (eval-env e env-empty)) + +(define program + '(car (if true (cons 1 2) false))) + +(define (test-eval) (eval (parse program))) \ No newline at end of file diff --git a/semestr-2/racket/lista6/lista8/zad4.rkt b/semestr-2/racket/lista6/lista8/zad4.rkt new file mode 100644 index 0000000..7934435 --- /dev/null +++ b/semestr-2/racket/lista6/lista8/zad4.rkt @@ -0,0 +1,118 @@ +#lang racket + +; Do boolean.rkt dodajemy pary +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct cons-expr (e1 e2) #:transparent) ; <------------------- !!! +(struct car-expr (e) #:transparent) ; <------------------- !!! +(struct cdr-expr (e) #:transparent) ; <------------------- !!! +(struct is-pair (e) #:transparent) + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) + (and (expr? eb) (expr? et) (expr? ef))] + [(cons-expr e1 e2) (and (expr? e1) (expr? e2))] ; <----------- !!! + [(car-expr e) (expr? e)] ; <---------------------------------- !!! + [(cdr-expr e) (expr? e)] ; <---------------------------------- !!! + [(is-pair e) (expr? e)] + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'cons)) ; <- !!! + (cons-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'car)) ; <-- !!! + (car-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'cdr)) ; <-- !!! + (cdr-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'pair?)) + (is-pair (parse (second q)))])) + +(define (test-parse) (parse '(let [x (+ 2 2)] (+ x 1)))) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs)) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(define (value? v) + (or (number? v) + (boolean? v) + (and (pair? v) (value? (car v)) (value? (cdr v))))) + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))])) + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) + (eval-env et env) + (eval-env ef env))] + [(cons-expr e1 e2) (cons (eval-env e1 env) ; <---------------- !!! + (eval-env e2 env))] + [(car-expr e) (car (eval-env e env))] ; <--------------------- !!! + [(cdr-expr e) (cdr (eval-env e env))] ; <------------------- !!! + [(is-pair e) (cons? (eval-env e env))])) +(define (eval e) (eval-env e env-empty)) + +(define program + '(car (if true (cons 1 2) false))) + +(define (test-eval) (eval (parse program))) \ No newline at end of file diff --git a/semestr-2/racket/lista6/lista8/zad5.bak b/semestr-2/racket/lista6/lista8/zad5.bak new file mode 100644 index 0000000..6f1f7b4 --- /dev/null +++ b/semestr-2/racket/lista6/lista8/zad5.bak @@ -0,0 +1 @@ +#lang racket diff --git a/semestr-2/racket/lista6/lista8/zad5.rkt b/semestr-2/racket/lista6/lista8/zad5.rkt new file mode 100644 index 0000000..721f5bf --- /dev/null +++ b/semestr-2/racket/lista6/lista8/zad5.rkt @@ -0,0 +1,151 @@ +#lang racket + +; Do list.rkt dodajemy procedury +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct unop (op e) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct cons-expr (e1 e2) #:transparent) +(struct null-expr () #:transparent) +(struct null?-expr (e) #:transparent) +(struct app (f e) #:transparent) ; <------------------ !!! +(struct lam (id e) #:transparent) ; <------------------ !!! + + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) + (and (expr? eb) (expr? et) (expr? ef))] + [(cons-expr e1 e2) (and (expr? e1) (expr? e2))] + [(null-expr) true] + [(null?-expr e) (expr? e)] + [(app f e) (and (expr? f) (expr? e))] ; <--------------------- !!! + [(lam id e) (and (symbol? id) (expr? e))] ; <----------------- !!! + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (null-expr)] + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'null?)) + (null?-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'cons)) + (cons-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'lambda)) ; proc (car q)))) ; <------- !!! + (parse-app q)] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (symbol? (first q))) + (unop (first q) (parse (second q)))])) + +(define (parse-app q) ; <----------------------------------------- !!! + (define (parse-app-accum q acc) + (cond [(= 1 (length q)) (app acc (parse (car q)))] + [else (parse-app-accum (cdr q) (app acc (parse (car q))))])) + (parse-app-accum (cdr q) (parse (car q)))) + +(define (parse-lam pat e) ; <------------------------------------- !!! + (cond [(= 1 (length pat)) + (lam (car pat) (parse e))] + [else + (lam (car pat) (parse-lam (cdr pat) e))])) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs) #:transparent) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(struct clo (id e env) #:transparent) ; <------------------------- !!! + +(define (value? v) + (or (number? v) + (boolean? v) + (and (pair? v) (value? (car v)) (value? (cdr v))) + (null? v) + (clo? v))) ; <---------------------------------------------- !!! + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))] + ['not not] ['car car] ['cdr cdr] + [_ false])) ; <--------------------------------------- !!! + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(unop op e) ((op->proc op) (eval-env e env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) + (eval-env et env) + (eval-env ef env))] + [(cons-expr e1 e2) (cons (eval-env e1 env) + (eval-env e2 env))] + [(null-expr) null] + [(null?-expr e) (null? (eval-env e env))] + [(lam x e) (clo x e env)] ; <--------------------------------- !!! + [(app f e) ; <------------------------------------------------ !!! + (let ([vf (eval-env f env)] + [ve (eval-env e env)]) + (match vf [(clo x body fun-env) + (eval-env body (env-add x ve fun-env))]))])) + +(define (eval e) (eval-env e env-empty)) + +(define program + '(let [twice (lambda (f x) (f (f x)))] + (let [inc (lambda (x) (+ 1 x))] + (twice twice twice twice inc 1)))) + + +(define (test-eval) (eval (parse program))) \ No newline at end of file diff --git a/semestr-2/racket/lista6/lista8/zad6.bak b/semestr-2/racket/lista6/lista8/zad6.bak new file mode 100644 index 0000000..721f5bf --- /dev/null +++ b/semestr-2/racket/lista6/lista8/zad6.bak @@ -0,0 +1,151 @@ +#lang racket + +; Do list.rkt dodajemy procedury +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct unop (op e) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct cons-expr (e1 e2) #:transparent) +(struct null-expr () #:transparent) +(struct null?-expr (e) #:transparent) +(struct app (f e) #:transparent) ; <------------------ !!! +(struct lam (id e) #:transparent) ; <------------------ !!! + + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) + (and (expr? eb) (expr? et) (expr? ef))] + [(cons-expr e1 e2) (and (expr? e1) (expr? e2))] + [(null-expr) true] + [(null?-expr e) (expr? e)] + [(app f e) (and (expr? f) (expr? e))] ; <--------------------- !!! + [(lam id e) (and (symbol? id) (expr? e))] ; <----------------- !!! + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (null-expr)] + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'null?)) + (null?-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'cons)) + (cons-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'lambda)) ; proc (car q)))) ; <------- !!! + (parse-app q)] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (symbol? (first q))) + (unop (first q) (parse (second q)))])) + +(define (parse-app q) ; <----------------------------------------- !!! + (define (parse-app-accum q acc) + (cond [(= 1 (length q)) (app acc (parse (car q)))] + [else (parse-app-accum (cdr q) (app acc (parse (car q))))])) + (parse-app-accum (cdr q) (parse (car q)))) + +(define (parse-lam pat e) ; <------------------------------------- !!! + (cond [(= 1 (length pat)) + (lam (car pat) (parse e))] + [else + (lam (car pat) (parse-lam (cdr pat) e))])) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs) #:transparent) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(struct clo (id e env) #:transparent) ; <------------------------- !!! + +(define (value? v) + (or (number? v) + (boolean? v) + (and (pair? v) (value? (car v)) (value? (cdr v))) + (null? v) + (clo? v))) ; <---------------------------------------------- !!! + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))] + ['not not] ['car car] ['cdr cdr] + [_ false])) ; <--------------------------------------- !!! + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(unop op e) ((op->proc op) (eval-env e env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) + (eval-env et env) + (eval-env ef env))] + [(cons-expr e1 e2) (cons (eval-env e1 env) + (eval-env e2 env))] + [(null-expr) null] + [(null?-expr e) (null? (eval-env e env))] + [(lam x e) (clo x e env)] ; <--------------------------------- !!! + [(app f e) ; <------------------------------------------------ !!! + (let ([vf (eval-env f env)] + [ve (eval-env e env)]) + (match vf [(clo x body fun-env) + (eval-env body (env-add x ve fun-env))]))])) + +(define (eval e) (eval-env e env-empty)) + +(define program + '(let [twice (lambda (f x) (f (f x)))] + (let [inc (lambda (x) (+ 1 x))] + (twice twice twice twice inc 1)))) + + +(define (test-eval) (eval (parse program))) \ No newline at end of file diff --git a/semestr-2/racket/lista6/lista8/zad6.rkt b/semestr-2/racket/lista6/lista8/zad6.rkt new file mode 100644 index 0000000..c7ea9f0 --- /dev/null +++ b/semestr-2/racket/lista6/lista8/zad6.rkt @@ -0,0 +1,171 @@ +#lang racket + +; Do list.rkt dodajemy procedury +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct unop (op e) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) +(struct cons-expr (e1 e2) #:transparent) +(struct null-expr () #:transparent) +(struct null?-expr (e) #:transparent) +(struct app (f e) #:transparent) ; <------------------ !!! +(struct lam (id e) #:transparent) ; <------------------ !!! + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] + [(unop op e) (and (symbol? op) (expr? e))] + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) + (and (expr? eb) (expr? et) (expr? ef))] + [(cons-expr e1 e2) (and (expr? e1) (expr? e2))] + [(null-expr) true] + [(null?-expr e) (expr? e)] + [(app f e) (and (expr? f) (expr? e))] ; <--------------------- !!! + [(lam id e) (and (symbol? id) (expr? e))] ; <----------------- !!! + [_ false])) + +(define (cedar? f) + (let ((letters (string->list (symbol->string f)))) + (and (> (length letters) 2) + (eq? (first letters) #\c) + (eq? (first (reverse letters)) #\r) + (andmap (lambda (x) (or (eq? x #\a) (eq? x #\d))) + (cdr letters))))) + +(define (get-cedar letters xs) + (cond [(eq? (car letters) #\r) xs] + [(eq? (car letters) #\a) (unop 'car (get-cedar (cdr letters) xs))] + [(eq? (car letters) #\d) (unop 'cdr (get-cedar (cdr letters) xs))])) + +(define (cedar f xs) + (let ((letters (string->list (symbol->string f)))) + (get-cedar (cdr (reverse letters)) xs))) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] + [(eq? q 'false) (const false)] + [(eq? q 'null) (null-expr)] + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 2) (eq? (first q) 'null?)) + (null?-expr (parse (second q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'cons)) + (cons-expr (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'lambda)) ; proc (car q)))) ; <------- !!! + (parse-app q)] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))] + [(and (list? q) (eq? (length q) 2) (symbol? (first q))) + (unop (first q) (parse (second q)))])) + +(define (parse-app q) ; <----------------------------------------- !!! + (define (parse-app-accum q acc) + (cond [(= 1 (length q)) (app acc (parse (car q)))] + [else (parse-app-accum (cdr q) (app acc (parse (car q))))])) + (parse-app-accum (cdr q) (parse (car q)))) + +(define (parse-lam pat e) ; <------------------------------------- !!! + (cond [(= 1 (length pat)) + (lam (car pat) (parse e))] + [else + (lam (car pat) (parse-lam (cdr pat) e))])) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs) #:transparent) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(struct clo (id e env) #:transparent) ; <------------------------- !!! + +(define (value? v) + (or (number? v) + (boolean? v) + (and (pair? v) (value? (car v)) (value? (cdr v))) + (null? v) + (clo? v))) ; <---------------------------------------------- !!! + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))] + ['not not] ['car car] ['cdr cdr] + [_ false])) ; <--------------------------------------- !!! + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(unop op e) ((op->proc op) (eval-env e env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) + (eval-env et env) + (eval-env ef env))] + [(cons-expr e1 e2) (cons (eval-env e1 env) + (eval-env e2 env))] + [(null-expr) null] + [(null?-expr e) (null? (eval-env e env))] + [(lam x e) (clo x e env)] ; <--------------------------------- !!! + [(app f e) ; <------------------------------------------------ !!! + (let ([vf (eval-env f env)] + [ve (eval-env e env)]) + (match vf [(clo x body fun-env) + (eval-env body (env-add x ve fun-env))]))])) + +(define (eval e) (eval-env e env-empty)) + +(define program + '(let [twice (lambda (f x) (f (f x)))] + (let [inc (lambda (x) (+ 1 x))] + (twice twice twice twice inc 1)))) + + +(define (test-eval) (eval (parse program))) \ No newline at end of file diff --git a/semestr-2/racket/lista6/lista8/zadanie.rkt b/semestr-2/racket/lista6/lista8/zadanie.rkt new file mode 100644 index 0000000..0960f21 --- /dev/null +++ b/semestr-2/racket/lista6/lista8/zadanie.rkt @@ -0,0 +1,98 @@ +#lang racket + +; Do let-env.rkt dodajemy wartosci boolowskie +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) +(struct var-expr (id) #:transparent) +(struct let-expr (id e1 e2) #:transparent) +(struct if-expr (eb et ef) #:transparent) + +(define (expr? e) + (match e + [(const n) (or (number? n) (boolean? n))] ; <----------------- !!! + [(binop op l r) (and (symbol? op) (expr? l) (expr? r))] + [(var-expr x) (symbol? x)] + [(let-expr x e1 e2) + (and (symbol? x) (expr? e1) (expr? e2))] + [(if-expr eb et ef) ; <--------------------------------------- !!! + (and (expr? eb) (expr? et) (expr? ef))] + [_ false])) + +(define (parse q) + (cond + [(number? q) (const q)] + [(eq? q 'true) (const true)] ; <---------------------------- !!! + [(eq? q 'false) (const false)] ; <---------------------------- !!! + [(symbol? q) (var-expr q)] + [(and (list? q) (eq? (length q) 3) (eq? (first q) 'let)) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(and (list? q) (eq? (length q) 4) (eq? (first q) 'if)) ; <--- !!! + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) + (parse (second q)) + (parse (third q)))])) + +(define (test-parse) (parse '(let [x (+ 2 2)] (+ x 1)))) + +; ---------- ; +; Srodowiska ; +; ---------- ; + +(struct environ (xs)) + +(define env-empty (environ null)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(define (env-lookup x env) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + +; --------- ; +; Ewaluacja ; +; --------- ; + +(define (value? v) + (or (number? v) (boolean? v))) + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /] ['% modulo] ; <----------- !!! + ['= =] ['> >] ['>= >=] ['< <] ['<= <=] + ['and (lambda (x y) (and x y))] + ['or (lambda (x y) (or x y))])) + +(define (eval-env e env) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval-env l env) + (eval-env r env))] + [(let-expr x e1 e2) + (eval-env e2 (env-add x (eval-env e1 env) env))] + [(var-expr x) (env-lookup x env)] + [(if-expr eb et ef) (if (eval-env eb env) ; <----------------- !!! + (eval-env et env) + (eval-env ef env))])) + +(define (eval e) (eval-env e env-empty)) + +(define program + '(if (or (< (% 123 10) 5) + true) + (+ 2 3) + (/ 2 0))) + +(define (test-eval) (eval (parse program))) \ No newline at end of file diff --git a/semestr-2/racket/lista6/solution.bak b/semestr-2/racket/lista6/solution.bak new file mode 100644 index 0000000..0805991 --- /dev/null +++ b/semestr-2/racket/lista6/solution.bak @@ -0,0 +1,27 @@ +#lang racket + +(provide (struct-out complex) parse eval) + +(struct complex (re im) #:transparent) + +(define value? + complex?) + +;; Ponizej znajduje sie interpreter zwyklych wyrazen arytmetycznych. +;; Zadanie to zmodyfikowac go tak, by dzialal z liczbami zespolonymi. + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /])) + +(define (eval e) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval l) (eval r))])) + +(define (parse q) + (cond [(number? q) (const q)] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) (parse (second q)) (parse (third q)))])) \ No newline at end of file diff --git a/semestr-2/racket/lista6/solution.rkt b/semestr-2/racket/lista6/solution.rkt new file mode 100644 index 0000000..59bdecd --- /dev/null +++ b/semestr-2/racket/lista6/solution.rkt @@ -0,0 +1,73 @@ +#lang racket + +(provide (struct-out complex) parse eval) + +(struct complex (re im) #:transparent) + +(define value? + complex?) + +(define (comp-plus x y) + (let ((x-re (complex-re x)) + (x-im (complex-im x)) + (y-re (complex-re y)) + (y-im (complex-im y))) + (complex (+ x-re y-re) (+ x-im y-im)))) + +(define (comp-minus x y) + (let ((x-re (complex-re x)) + (x-im (complex-im x)) + (y-re (complex-re y)) + (y-im (complex-im y))) + (complex (- x-re y-re) (- x-im y-im)))) + +(define (comp-mult x y) + (let ((x-re (complex-re x)) + (x-im (complex-im x)) + (y-re (complex-re y)) + (y-im (complex-im y))) + (complex (- (* x-re y-re) (* x-im y-im)) (+ (* x-re y-im) (* x-im y-re))))) + +(define (comp-mod2 x) + (let ((x-re (complex-re x)) + (x-im (complex-im x))) + (complex (+ (* x-re x-re) (* x-im x-im)) 0))) + +(define (comp-mod x) + (let ((mod2 (comp-mod2 x)) + (x-re (complex-re x))) + (complex (sqrt x-re) 0))) + +(define (comp-div x y) + (let* ((mod2 (complex-re (comp-mod2 y))) + (x-re (complex-re x)) + (x-im (complex-im x)) + (y-re (complex-re y)) + (y-im (complex-im y)) + (real (+ (* x-re y-re) (* x-im y-im))) + (imag (- (* x-im y-re) (* x-re y-im)))) + (complex (/ real mod2) (/ imag mod2)))) + + +;; Ponizej znajduje sie interpreter zwyklych wyrazen arytmetycznych. +;; Zadanie to zmodyfikowac go tak, by dzialal z liczbami zespolonymi. + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) + +(define (imaginary-unit? c) + (eq? c 'i)) + +(define (op->proc op) + (match op ['+ comp-plus] ['- comp-minus] ['* comp-mult] ['/ comp-div])) + +(define (eval e) + (match e + [(const n) n] + [(binop op l r) ((op->proc op) (eval l) (eval r))])) + +(define (parse q) + (cond [(number? q) (const (complex q 0))] + [(imaginary-unit? q) (const (complex 0 1))] + [(and (list? q) (eq? (length q) 3) (symbol? (first q))) + (binop (first q) (parse (second q)) (parse (third q)))])) \ No newline at end of file diff --git a/semestr-2/racket/lista6/zad11/solution.bak b/semestr-2/racket/lista6/zad11/solution.bak new file mode 100644 index 0000000..f449481 --- /dev/null +++ b/semestr-2/racket/lista6/zad11/solution.bak @@ -0,0 +1,36 @@ +#lang racket + +(provide (struct-out const) (struct-out binop) rpn->arith) + +;; ------------------------------- +;; Wyrazenia w odwr. not. polskiej +;; ------------------------------- + +(define (rpn-expr? e) + (and (list? e) + (pair? e) + (andmap (lambda (x) (or (number? x) (member x '(+ - * /)))) + e))) + +;; ---------------------- +;; Wyrazenia arytmetyczne +;; ---------------------- + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) + +(define (arith-expr? e) + (match e + [(const n) (number? n)] + [(binop op l r) + (and (symbol? op) (arith-expr? l) (arith-expr? r))] + [_ false])) + +;; ---------- +;; Kompilacja +;; ---------- + +(define (rpn->arith e) + (error "TODO: Uzupelnij tutaj")) + +; Mozesz tez dodac jakies procedury pomocnicze i testy \ No newline at end of file diff --git a/semestr-2/racket/lista6/zad11/solution.rkt b/semestr-2/racket/lista6/zad11/solution.rkt new file mode 100644 index 0000000..a44afe4 --- /dev/null +++ b/semestr-2/racket/lista6/zad11/solution.rkt @@ -0,0 +1,58 @@ +#lang racket + +(provide (struct-out const) (struct-out binop) rpn->arith) + +;; ------------------------------- +;; Wyrazenia w odwr. not. polskiej +;; ------------------------------- + +(define (rpn-expr? e) + (and (list? e) + (pair? e) + (andmap (lambda (x) (or (number? x) (member x '(+ - * /)))) + e))) + +;; ---------------------- +;; Wyrazenia arytmetyczne +;; ---------------------- + +(struct const (val) #:transparent) +(struct binop (op l r) #:transparent) + +(define (arith-expr? e) + (match e + [(const n) (number? n)] + [(binop op l r) + (and (symbol? op) (arith-expr? l) (arith-expr? r))] + [_ false])) + +;; ---------- +;; Kompilacja +;; ---------- + +(struct stack (xs)) + +(define empty-stack (stack null)) +(define (empty-stack? s) (null? (stack-xs s))) +(define (top s) (car (stack-xs s))) +(define (push a s) (stack (cons a (stack-xs s)))) +(define (pop s) (stack (cdr (stack-xs s)))) + +(define (op->proc op) + (match op ['+ +] ['- -] ['* *] ['/ /])) + +(define (eval-am e s) + (cond [(null? e) + (top s)] + [(number? (car e)) + (eval-am (cdr e) (push (const (car e)) s))] + [(symbol? (car e)) + (eval-am (cdr e) + (push (binop (car e) (top (pop s)) (top s)) + (pop (pop s))))])) + +(define (rpn->arith e) + (eval-am e empty-stack)) + + +; Mozesz tez dodac jakies procedury pomocnicze i testy \ No newline at end of file diff --git a/semestr-2/racket/luk.rkt b/semestr-2/racket/luk.rkt new file mode 100644 index 0000000..cc319a5 --- /dev/null +++ b/semestr-2/racket/luk.rkt @@ -0,0 +1,137 @@ +#lang typed/racket + +; Do let-env.rkt dodajemy wartosci boolowskie +; +; Miejsca, ktore sie zmienily oznaczone sa przez !!! + +; --------- ; +; Wyrazenia ; +; --------- ; +(provide parse typecheck) + +(define-type Value (U Boolean Real)) +(define-type Expr (U const binop var-expr let-expr if-expr)) +(define-type ArithSymbol (U '+ '- '* '/)) +(define-type LogicSymbol (U 'and 'or)) +(define-type CompSymbol (U '< '= '> '<= '>=)) +(define-type BinomSymbol (U ArithSymbol LogicSymbol CompSymbol)) + +(define-type Binop-list (List BinomSymbol Any Any)) +(define-type Let-list (List 'let (List Symbol Any) Any)) +(define-type If-list (List 'if Any Any Any)) + +(define-predicate Binop-list? Binop-list) +(define-predicate Let-list? Let-list) +(define-predicate If-list? If-list) + +(struct const ([val : Value]) #:transparent) +(struct binop ([op : BinomSymbol] [l : Expr] [r : Expr]) #:transparent) +(struct var-expr ([id : Symbol]) #:transparent) +(struct let-expr ([id : Symbol] [e1 : Expr] [e2 : Expr]) #:transparent) +(struct if-expr ([eb : Expr] [et : Expr] [ef : Expr]) #:transparent) + +(define-predicate Value? Value) +(define-predicate Expr? Expr) +(define-predicate BinomSymbol? BinomSymbol) +(define-predicate ArithSymbol? ArithSymbol) +(define-predicate LogicSymbol? LogicSymbol) +(define-predicate CompSymbol? CompSymbol) +(define-predicate BinomValue? BinomValue) + + + +(: parse (-> Any Expr)) +(define (parse q) + (cond + [(real? q) (const q)] + [(eq? q 'true) (const true)] ; <---------------------------- !!! + [(eq? q 'false) (const false)] ; <---------------------------- !!! + [(symbol? q) (var-expr q)] + [(Let-list? q) + (let-expr (first (second q)) + (parse (second (second q))) + (parse (third q)))] + [(If-list? q) ; <--- !!! + (if-expr (parse (second q)) + (parse (third q)) + (parse (fourth q)))] + [(Binop-list? q) + (binop (first q) + (parse (second q)) + (parse (third q)))] + [else (error "Blad parsowania" q)])) + + + + +(define (test-parse) (parse '(let [x (+ 2 2)] (+ x 1)))) + +; ---------- ; +; Srodowiska ; +; ---------- ; +(define-type EType ( U 'real 'boolean ) ) +(define-type Env (Listof (Pairof Symbol EType))) +(define-predicate Env? Env) +(struct environ ([xs : Env])) + +(: env-empty environ) +(define env-empty (environ null)) +(: env-add (-> Symbol EType environ environ)) +(define (env-add x v env) + (environ (cons (cons x v) (environ-xs env)))) +(: env-lookup (-> Symbol environ (U EType #f))) +(define (env-lookup x env) + (: assoc-lookup (-> Env EType)) + (define (assoc-lookup xs) + (cond [(null? xs) (error "Unknown identifier" x)] + [(eq? x (car (car xs))) (cdr (car xs))] + [else (assoc-lookup (cdr xs))])) + (assoc-lookup (environ-xs env))) + + +(: typecheck (-> Expr (U EType #f))) +(define (typecheck q) + (: give (-> Expr environ (U EType #f))) + (define (give q envi) + (cond + [(const? q) (if (boolean? (const-val q)) 'boolean 'real)] + [(var-expr? q) (env-lookup (var-expr-id q) envi)] + [(let-expr? q) + (let ([p (give (let-expr-e1 q) envi)]) (if (false? p) #f (give (let-expr-e2 q) (env-add (let-expr-id q) p envi))))] + [(binop? q) + (cond + ([ArithSymbol? (binop-op q)] (if (and (eq? 'real (give (binop-l q) envi)) (eq? 'real (give (binop-r q) envi))) 'real #f)) + ([LogicSymbol? (binop-op q)] (if (and (eq? 'boolean (give (binop-l q) envi)) (eq? 'boolean (give (binop-r q) envi))) 'boolean #f)) + ([CompSymbol? (binop-op q)] (if (and (eq? 'real (give (binop-l q) envi)) (eq? 'real (give (binop-r q) envi))) 'boolean #f)) + [else #f])] + [(if-expr? q) + (if (and (eq? 'real (if-expr-eb q)) + (eq? (give (if-expr-et q) envi) (give (if-expr-ef q) envi))) + (give (if-expr-et q) envi) + #f)] + [else #f])) + + + (give q env-empty)) + + + +(define program2 + '(if true + (let [x 5] (+ 5 false)) + (/ 2 2))) + +(define program3 + '(let [x (+ 2 3)] + (let [y (< 2 3)] + (+ x y)))) + +(define program4 + '(let [x (and true true)] x)) + +(define wtf + '(and true true)) + +(typecheck (parse program2)) +(typecheck (parse program3)) +(typecheck (parse program4)) diff --git a/semestr-2/racket/rac.rkt b/semestr-2/racket/rac.rkt new file mode 100644 index 0000000..8300208 --- /dev/null +++ b/semestr-2/racket/rac.rkt @@ -0,0 +1,371 @@ +#reader(lib"read.ss""wxme")WXME0109 ## +#| + This file uses the GRacket editor format. + Open this file in DrRacket version 7.6 or later to read it. + + Most likely, it was created by saving a program in DrRacket, + and it probably contains a program with non-text elements + (such as images or comment boxes). + + http://racket-lang.org/ +|# + 33 7 #"wxtext\0" +3 1 6 #"wxtab\0" +1 1 8 #"wximage\0" +2 0 8 #"wxmedia\0" +4 1 34 #"(lib \"syntax-browser.ss\" \"mrlib\")\0" +1 0 36 #"(lib \"cache-image-snip.ss\" \"mrlib\")\0" +1 0 68 +(0 + #"((lib \"image-core.ss\" \"mrlib\") (lib \"image-core-wxme.rkt\" \"mr" + #"lib\"))\0" +) 1 0 16 #"drscheme:number\0" +3 0 44 #"(lib \"number-snip.ss\" \"drscheme\" \"private\")\0" +1 0 36 #"(lib \"comment-snip.ss\" \"framework\")\0" +1 0 93 +(1 + #"((lib \"collapsed-snipclass.ss\" \"framework\") (lib \"collapsed-sni" + #"pclass-wxme.ss\" \"framework\"))\0" +) 0 0 43 #"(lib \"collapsed-snipclass.ss\" \"framework\")\0" +0 0 19 #"drscheme:sexp-snip\0" +0 0 29 #"drscheme:bindings-snipclass%\0" +1 0 101 +(2 + #"((lib \"ellipsis-snip.rkt\" \"drracket\" \"private\") (lib \"ellipsi" + #"s-snip-wxme.rkt\" \"drracket\" \"private\"))\0" +) 2 0 88 +(3 + #"((lib \"pict-snip.rkt\" \"drracket\" \"private\") (lib \"pict-snip.r" + #"kt\" \"drracket\" \"private\"))\0" +) 0 0 55 +#"((lib \"snip.rkt\" \"pict\") (lib \"snip-wxme.rkt\" \"pict\"))\0" +1 0 34 #"(lib \"bullet-snip.rkt\" \"browser\")\0" +0 0 25 #"(lib \"matrix.ss\" \"htdp\")\0" +1 0 22 #"drscheme:lambda-snip%\0" +1 0 29 #"drclickable-string-snipclass\0" +0 0 26 #"drracket:spacer-snipclass\0" +0 0 57 +#"(lib \"hrule-snip.rkt\" \"macro-debugger\" \"syntax-browser\")\0" +1 0 26 #"drscheme:pict-value-snip%\0" +0 0 45 #"(lib \"image-snipr.ss\" \"slideshow\" \"private\")\0" +1 0 38 #"(lib \"pict-snipclass.ss\" \"slideshow\")\0" +2 0 55 #"(lib \"vertical-separator-snip.ss\" \"stepper\" \"private\")\0" +1 0 18 #"drscheme:xml-snip\0" +1 0 31 #"(lib \"xml-snipclass.ss\" \"xml\")\0" +1 0 21 #"drscheme:scheme-snip\0" +2 0 34 #"(lib \"scheme-snipclass.ss\" \"xml\")\0" +1 0 10 #"text-box%\0" +1 0 32 #"(lib \"text-snipclass.ss\" \"xml\")\0" +1 0 1 6 #"wxloc\0" + 0 0 64 0 1 #"\0" +0 75 1 #"\0" +0 10 90 -1 90 -1 3 -1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 255 255 255 1 -1 0 9 +#"Standard\0" +0 75 12 #"Courier New\0" +0 26 90 -1 90 -1 3 -1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 255 255 255 1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 -1 -1 2 24 +#"framework:default-color\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 150 0 150 0 0 0 -1 -1 2 15 +#"text:ports out\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 150 0 150 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1.0 0 -1 -1 93 -1 -1 -1 0 0 0 0 0 0 0 0 0 1.0 1.0 1.0 255 0 0 0 0 0 -1 +-1 2 15 #"text:ports err\0" +0 -1 1 #"\0" +1 0 -1 -1 93 -1 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 255 0 0 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 175 0 0 0 -1 -1 2 17 +#"text:ports value\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 175 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1.0 0 92 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1.0 1.0 1.0 34 139 34 0 0 0 -1 +-1 2 27 #"Matching Parenthesis Style\0" +0 -1 1 #"\0" +1.0 0 92 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1.0 1.0 1.0 34 139 34 0 0 0 -1 +-1 2 1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 38 38 128 0 0 0 -1 -1 2 37 +#"framework:syntax-color:scheme:symbol\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 38 38 128 0 0 0 -1 -1 2 38 +#"framework:syntax-color:scheme:keyword\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 38 38 128 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 194 116 31 0 0 0 -1 -1 2 +38 #"framework:syntax-color:scheme:comment\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 194 116 31 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 41 128 38 0 0 0 -1 -1 2 37 +#"framework:syntax-color:scheme:string\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 41 128 38 0 0 0 -1 -1 2 35 +#"framework:syntax-color:scheme:text\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 41 128 38 0 0 0 -1 -1 2 39 +#"framework:syntax-color:scheme:constant\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 41 128 38 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 132 60 36 0 0 0 -1 -1 2 49 +#"framework:syntax-color:scheme:hash-colon-keyword\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 132 60 36 0 0 0 -1 -1 2 42 +#"framework:syntax-color:scheme:parenthesis\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 132 60 36 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 255 0 0 0 0 0 -1 -1 2 36 +#"framework:syntax-color:scheme:error\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 255 0 0 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 -1 -1 2 36 +#"framework:syntax-color:scheme:other\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 -1 -1 2 16 +#"Misspelled Text\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 81 112 203 0 0 0 -1 -1 2 +38 #"drracket:check-syntax:lexically-bound\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 81 112 203 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 178 34 34 0 0 0 -1 -1 2 28 +#"drracket:check-syntax:set!d\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 178 34 34 0 0 0 -1 -1 2 37 +#"drracket:check-syntax:unused-require\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 255 0 0 0 0 0 -1 -1 2 36 +#"drracket:check-syntax:free-variable\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 255 0 0 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 68 0 203 0 0 0 -1 -1 2 31 +#"drracket:check-syntax:imported\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 68 0 203 0 0 0 -1 -1 2 47 +#"drracket:check-syntax:my-obligation-style-pref\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 178 34 34 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 0 116 0 0 0 0 -1 -1 2 50 +#"drracket:check-syntax:their-obligation-style-pref\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 0 116 0 0 0 0 -1 -1 2 48 +#"drracket:check-syntax:unk-obligation-style-pref\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 139 142 28 0 0 0 -1 -1 2 +49 #"drracket:check-syntax:both-obligation-style-pref\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 139 142 28 0 0 0 -1 -1 2 +26 #"plt:htdp:test-coverage-on\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 -1 -1 2 1 +#"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 1 0 0 0 0 0 0 255 165 0 0 0 0 -1 -1 2 27 +#"plt:htdp:test-coverage-off\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 1 0 0 0 0 0 0 255 165 0 0 0 0 -1 -1 4 1 +#"\0" +0 70 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 1.0 1.0 1.0 1.0 1.0 1.0 0 0 0 0 0 0 +-1 -1 4 4 #"XML\0" +0 70 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 1.0 1.0 1.0 1.0 1.0 1.0 0 0 0 0 0 0 +-1 -1 2 37 #"plt:module-language:test-coverage-on\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 -1 -1 2 38 +#"plt:module-language:test-coverage-off\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 93 -1 -1 0 1 0 0 0 1 0 0 0 0 0 0 255 165 0 0 0 0 -1 -1 0 36 +#"mrlib/syntax-browser:subtitle-color\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 1 0 0 0 0 0 0 36 36 140 255 255 255 -1 +-1 0 42 #"mrlib/syntax-browser:focused-syntax-color\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 1 0 0 0 0 0 0 34 139 34 255 255 255 -1 +-1 4 1 #"\0" +0 71 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 1.0 1.0 1.0 1.0 1.0 1.0 0 0 0 0 0 0 +-1 -1 4 1 #"\0" +0 -1 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 1 0 0 0 0 0 0 0 0 1.0 1.0 1.0 0 0 255 0 0 0 -1 +-1 4 1 #"\0" +0 71 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 1 0 0 0 0 0 0 0 0 1.0 1.0 1.0 0 0 255 0 0 0 -1 +-1 4 1 #"\0" +0 71 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1.0 1.0 1.0 0 100 0 0 0 0 -1 +-1 4 1 #"\0" +0 71 1 #"\0" +1.0 0 -1 -1 93 -1 -1 -1 0 0 0 0 0 0 0 0 0 1.0 1.0 1.0 255 0 0 0 0 0 -1 +-1 2 1 #"\0" +0 70 1 #"\0" +1.0 0 -1 -1 93 -1 -1 -1 0 0 0 0 0 0 0 0 0 1.0 1.0 1.0 148 0 211 0 0 0 -1 +-1 2 1 #"\0" +0 -1 1 #"\0" +1.0 0 -1 -1 -1 -1 -1 -1 1 0 0 0 0 0 0 0 0 1.0 1.0 1.0 0 0 255 0 0 0 -1 +-1 0 1 #"\0" +0 -1 1 #"\0" +0 12 -1 -1 -1 -1 -1 -1 0 0 1 0 0 0 1.0 1.0 1.0 1.0 1.0 1.0 0 0 0 0 0 0 +-1 -1 2 1 #"\0" +0 -1 1 #"\0" +0 12 -1 -1 -1 -1 -1 -1 0 0 1 0 0 0 1.0 1.0 1.0 1.0 1.0 1.0 0 0 0 0 0 0 +-1 -1 2 1 #"\0" +0 -1 1 #"\0" +1 0 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0 0 1 1 1 200 0 0 0 0 0 -1 -1 4 1 +#"\0" +0 -1 1 #"\0" +1.0 0 92 -1 -1 -1 -1 -1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 255 255 0 -1 -1 + 0 122 0 28 3 12 #"#lang racket" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 3 1 #"(" +0 0 15 3 6 #"define" +0 0 24 3 2 #" (" +0 0 14 3 6 #"fringe" +0 0 24 3 1 #" " +0 0 14 3 4 #"tree" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 15 3 4 #"cond" +0 0 24 3 3 #" ((" +0 0 14 3 5 #"null?" +0 0 24 3 1 #" " +0 0 14 3 4 #"tree" +0 0 24 3 2 #") " +0 0 14 3 4 #"null" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 10 #" ((" +0 0 14 3 3 #"not" +0 0 24 3 2 #" (" +0 0 14 3 5 #"pair?" +0 0 24 3 1 #" " +0 0 14 3 4 #"tree" +0 0 24 3 4 #")) (" +0 0 14 3 4 #"list" +0 0 24 3 1 #" " +0 0 14 3 4 #"tree" +0 0 24 3 2 #"))" +0 0 24 29 1 #"\n" +0 0 24 3 9 #" (" +0 0 14 3 4 #"else" +0 0 24 3 2 #" (" +0 0 14 3 6 #"append" +0 0 24 3 2 #" (" +0 0 14 3 6 #"fringe" +0 0 24 3 2 #" (" +0 0 14 3 3 #"car" +0 0 24 3 1 #" " +0 0 14 3 4 #"tree" +0 0 24 3 2 #"))" +0 0 24 29 1 #"\n" +0 0 24 3 23 #" (" +0 0 14 3 6 #"fringe" +0 0 24 3 2 #" (" +0 0 14 3 3 #"cdr" +0 0 24 3 1 #" " +0 0 14 3 4 #"tree" +0 0 24 3 6 #"))))))" +0 0 24 29 1 #"\n" +0 0 24 29 1 #"\n" +0 0 24 3 1 #"(" +0 0 15 3 6 #"define" +0 0 24 3 2 #" (" +0 0 14 3 7 #"subsets" +0 0 24 3 1 #" " +0 0 14 3 1 #"s" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 3 #" (" +0 0 14 3 2 #"if" +0 0 24 3 2 #" (" +0 0 14 3 5 #"null?" +0 0 24 3 1 #" " +0 0 14 3 1 #"s" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 7 #" (" +0 0 14 3 4 #"list" +0 0 24 3 1 #" " +0 0 14 3 4 #"null" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 7 #" (" +0 0 15 3 3 #"let" +0 0 24 3 3 #" ((" +0 0 14 3 4 #"rest" +0 0 24 3 2 #" (" +0 0 14 3 7 #"subsets" +0 0 24 3 2 #" (" +0 0 14 3 3 #"cdr" +0 0 24 3 1 #" " +0 0 14 3 1 #"s" +0 0 24 3 4 #"))))" +0 0 24 29 1 #"\n" +0 0 24 3 9 #" (" +0 0 14 3 7 #"display" +0 0 24 3 1 #" " +0 0 14 3 1 #"s" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 9 #" (" +0 0 14 3 7 #"newline" +0 0 24 3 1 #")" +0 0 24 29 1 #"\n" +0 0 24 3 9 #" (" +0 0 14 3 6 #"append" +0 0 24 3 1 #" " +0 0 14 3 4 #"rest" +0 0 24 3 2 #" (" +0 0 14 3 3 #"map" +0 0 24 3 2 #" (" +0 0 15 3 6 #"lambda" +0 0 24 3 2 #" (" +0 0 14 3 1 #"x" +0 0 24 3 3 #") (" +0 0 14 3 4 #"cons" +0 0 24 3 2 #" (" +0 0 14 3 3 #"car" +0 0 24 3 1 #" " +0 0 14 3 1 #"s" +0 0 24 3 2 #") " +0 0 14 3 1 #"x" +0 0 24 3 3 #")) " +0 0 14 3 4 #"rest" +0 0 24 3 5 #")))))" +0 0 24 29 1 #"\n" +0 0 24 3 2 #" " +0 0 diff --git a/semestr-2/racket/solution.rkt b/semestr-2/racket/solution.rkt new file mode 100644 index 0000000..3643668 --- /dev/null +++ b/semestr-2/racket/solution.rkt @@ -0,0 +1,14 @@ +#lang racket + +(provide heapsort) (require "leftist.rkt") + +(define (heapsort xs) + (define (create-heap xs res) + (if (null? xs) + res + (create-heap (cdr xs) (heap-insert (cons (car xs) (car xs)) res)))) + (define (heap-to-list h) + (if (heap-empty? h) + null + (cons (elem-val (heap-min h)) (heap-to-list (heap-pop h))))) + (heap-to-list (create-heap xs empty-heap))) \ No newline at end of file -- cgit v1.2.3