From a2260eda8810bab65c6a7da99b718c2ca33008b0 Mon Sep 17 00:00:00 2001 From: Lio Novelli Date: Tue, 30 Apr 2024 19:18:58 +0200 Subject: [PATCH] Dodani liotovi zapiski. --- zapiski/sicp-lio.org | 197 ++++++++++++++++++++++++++++++++++++++++ zapiski/sqrt-newton.scm | 74 +++++++++++++++ 2 files changed, 271 insertions(+) create mode 100644 zapiski/sicp-lio.org create mode 100644 zapiski/sqrt-newton.scm diff --git a/zapiski/sicp-lio.org b/zapiski/sicp-lio.org new file mode 100644 index 0000000..3594ee0 --- /dev/null +++ b/zapiski/sicp-lio.org @@ -0,0 +1,197 @@ +#+TITLE: Structure and Interpretation of Computer Programs +#+AUTHOR: Lio Novelli + +* Foreword and Preface + +#+begin_quote +Lisp je preživeli, v uporabi je že "polovico stoletja". +#+end_quote + +#+begin_quote +The discretionary exportable functionality entrusted to the individual Lisp programmer +is more than an order of magniture greater than that to be found within Pascal enterprises. +#+end_quote + +#+begin_quote +Želimo vzpostaviti idejo, da programski jezik ni samo način, da računalnik izvaja operacije, +ampak da je predvsem nov formalni medij za izražanje idej o metodologiji. Zato morajo biti +programi napisani predvsem zato, da jih ljudje berejo, in slučajno, da jih izvajajo računalniki. + +Bistvena tema ni sintaksa določenih struktur v programskem jeziku, niti ..., temveč tehnike +nadzora intelektualne kompleksnosti veliki programskih sistemov. +#+end_quote + +#+begin_quote +Naš pristop k temi izvira iz prepričanja, da "computer science" ni znanost in da ima njen +pomen bolj malo opraviti z računalniki. Računalniška revolucija je revolucija v načinu +mišljenja in izražanju idej. Bistvo teh sprememb najbolše opiše pojem +_proceduralne epistemologije_, ki se ukvarja s strukturo vednosti z imperativnega stališča +za razliko od klasične matematike, ki je bolj deklerativna. Matematika postavi okvir za +natančno spoprijemanje s pojmovanjem "kaj je". Računanje pa ponudi okvir za natančno +ukvarjanje s pojmovanjem "kako". +#+end_quote + +* 1. Grajenje abstrakcij s procedurami + + +** Elementi programiranja + +- Primitivni izrazi :: predstavtljajo najpreprostejše gradnike (entitete) + programskega jezika +- Načini kombinacije, :: s katerimi so sestavljeni elementi zgrajeni iz + preprostejših +- Načini abstrakcije, :: s katerimi so lahko sestavljeni elementi poimenovani in + omogočajo upravljanje z njimii kot enotami + +** Izvajanje kombinacij(e) + +Postopek za izvajanje kombinacij: +1. Izvedi podizraz kombinacije. +2. Uporabi/uveljavi proceduro, ki je najbolje levi podizraz (operator) z + argumenti, ki so vrednosti drugih podizrazov (operandi). + +Postopek evalvacije je rekurziven, saj drugi korak v sebi vključuje prvega, +oziroma vključuje svojo definicijo. + +Tako se zgradi akumulacijsko drevo. Na koncu vedno prideš do točke, ko izvajaš +primitivne izraze, ki so: +- vrednosti numeričnih števk, ki jo označujejo. +- vrednosti vgrajenih operatorjev so strojni ukazi sekvenc, ki izvedejo te + operacije. +- vrednosti drugih imen so objekti asociirani s temi imeni v okolju. + +Drugo pravilo je poseben primer tretjega pravila. Simboli + in * so tudi +vključeni v globalno okolje in so asociirani s strojnimi ukazi, ki so njihove +vrednosti. *Pomembno je prepoznati vlogo okolja pri določanju pomena simbolov v +izrazih.* + +To pravilo se ne nanaša na _posebne oblike (special forms)_. ~define~ je posebna +oblika. + + +** 1.1.4 Sestavljene procedure + +- Številke in aritmetične operacije so primitivni podatki in procedure. +- Gnezdenje kombinacij omogoča način za združevanje operacij. +- Definicije, ki asociirajo imena z vrednostmi omogočajo omejene načine + abstrakcije. + +~(define (square x) (* x x))~ + +~(define square (lambda (x) (* x x)))~ + +** 1.1.5 Substitucijski model za izvajanje procedur + +Za izvajanje sestavljenih procedur z argumenti, izvedeš telo procedure z vsakim +formalnim parametrom, ki ga nadomestiš s pripadajočim argumentom. + +_ergh, tukaj se zapletam s slovenskimi prevodi_ + +_kaj je application in kaj evaluation?_ + +Načini, na katere deluje interpreter (prevajalnik): +- Aplikativni vrstni red :: Najprej evalviraj operator in operande, potem pa + izvedi proizvedeno proceduro s pridobljenimi argumenti. +- Normalni vrstni red :: Ne izvajaj operandov dokler njihove vrednost niso + potrebne. Najprej zamenjaj izraze operandov s parametri, dokler ne pride do + izraza, ki vsebuje zgolj primitivne izraze in potem izvedi (vso) evalvacijo. + + +** meta + +Linki: +https://develop.spacemacs.org/layers/+lang/scheme/README.html +https://www.nongnu.org/geiser/ +https://www.gnu.org/software/guile/learn/ +https://spritely.institute/static/papers/scheme-primer.html#introduction + +Kako nastavit spacemacs, in malo o guile-u. + + +*** video lekcije + +https://yewtu.be/channel/UCEBb1b_L6zDS3xTUrIALZOw (6.001 SICP: Structure and Interpretation of Computer Programs (2004)) +https://yewtu.be/playlist?list=PL7BcsI5ueSNFPCEisbaoQ0kXIDX9rR5FF (MIT 6.001 Structure and Interpretation, 1986) + +** vaje + +*** 1.3 + +**** najprej narobe + +Define a procedure that takes three numbers as arguments and returns the sum of +the squares of the two larger numbers. + +#+begin_src scheme + (define (sum-of-large x y z) + (+ + (if (> x y) (* x x) (* y y)) + (if (> y z) (* y y) (* z z)) + ) + ) + (sum-of-large 3 8 5) +#+end_src + +#+RESULTS: +: 128 + +#+begin_src scheme + (define (sum-of-larger x y z) (let* + ((s (lambda (a) (* a a))) + (sl (lambda (b c) (if (> b c) (s b) (s c)))) + ) + (+ (sl x y) (sl y z)) + )) + (sum-of-larger 3 8 5) +#+end_src + +#+RESULTS: +: 128 + +**** pravilno + +#+begin_src scheme + (define (sum-squares-of-larger x y z) + (if (> x y) + (if (> y z) + (+ (* x x) (* y y)) + (+ (* x x) (* z z)) + ) + (if (> x z) + (+ (* y y) (* x x)) + (+ (* y y) (* z z)) + ) + ) + ) + (sum-squares-of-larger 9 10 8) +#+end_src + +#+RESULTS: +: 181 + +*** 1.5 + +Aplikativni vrstni red: pade takoj v neskoncno zanko. +Normalni vrstni red: izvrsi test in pride v if, ki ne izvrsi drugega dela. + +*** 1.6 + +[[file:sqrt-newton.scm][sqrt-newton.scm]] + +*** 1.7 + +- ~good-enough?~ ni vredu za iskanje korenov majhnih stevil. +- pravtako za zelo velika stevila +- napisi alternativno ~good-enough?~ proceduro, ki bo gledala, kdaj so spremembe + dovolj majhne in takrat prekini funkcijo. + +// Poglej v sqrt-newton.scm + +*** 1.8 + +// Glej v sqrt-newton.sqm + +** 1.1.8 Procedure kot crne skatle abstrakcij + +- block structure +- lexical scoping diff --git a/zapiski/sqrt-newton.scm b/zapiski/sqrt-newton.scm new file mode 100644 index 0000000..7f14492 --- /dev/null +++ b/zapiski/sqrt-newton.scm @@ -0,0 +1,74 @@ + +(define (sqrt-iter guess x) + (if (good-enough? guess x) + guess + (sqrt-iter (improve guess x) + x + ) + ) + ) + +(define (improve guess x) + (average guess (/ x guess)) + ) + +(define (average x y) + (/ (+ x y) 2) + ) + +(define (square x) (* x x)) + +(define (good-enough? guess x) + (< (abs (- (square guess) x)) 0.001) + ) + +(define (sqrt x) + (sqrt-iter 1.0 x) + ) + +(define (new-if predicate then-clause else-clause) + (cond (predicate then-clause) + (else else-clause) + ) + ) + +(define (new-sqrt-iter guess x) + "gre v neskoncni loop" + (new-if (good-enough? guess x) + guess + (new-sqrt-iter (improve guess x) + x + ) + ) + ) + +(define (abs x) + (if (> 0 x) (- x) x) + ) + +(define (better-enough? g1 g2) + "Sledimo spremembam priblizkov. Ustavimo, ko je sprememba majhen delez priblizka." + (< (/ (- g1 g2) g1) 0.0001) + ) + +(define (better-sqrt-iter guess x) + "Better sqrt. Naloga 1.8." + (let ((g2 (improve guess x))) + (if (better-enough? g2 guess) + g2 + (better-sqrt-iter g2 x) + ) + ) + ) + +(define (improve-cube-root guess x) + (/ (+ (* 2 guess) (/ x (* guess guess))) 3) + ) + +(define (cube-root-iter guess x) + "Tretji koren" + (if (good-enough? guess x) + guess + (cube-root-iter (improve-cube-root guess x) x) + ) + )