W dniu czwartek, 3 stycznia 2019 22:21:26 UTC+1 użytkownik g...@g...com
napisał:
> W dniu czwartek, 3 stycznia 2019 21:51:47 UTC+1 użytkownik fir napisał:
> > W dniu czwartek, 3 stycznia 2019 18:20:04 UTC+1 użytkownik g...@g...com
napisał:
> > >
> > > Przykład, który lubię dawać na różnych prezentacjach, to program
> > > liczący sumę kwadratów początkowych siedmiu liczb pierwszych.
> > >
> > > Imperatywnie zapisalibyśmy go tak:
> > >
> > > 1: licznik := 7
> > > 2: liczba := 0
> > > 3: suma := 0
> > > 4: dopóki (licznik > 0):
> > > 5: jeżeli jest_pierwsza(liczba):
> > > 6: suma := suma + liczba^2
> > > 7: licznik := licznik - 1
> > > 8: liczba := liczba + 1
> > >
> > > i jeszcze musieli dopowiedzieć, że po wykonaniu programu
> > > wynik znajdziemy w zmiennej "suma".
> > >
> > > Natomiast przy podejściu funkcyjnym po prostu "formalizujemy"
> > > sformułowaine problemu: "suma kwadratów początkowych 7 liczb pierwszych"
> > > ma swoją strukturę gramatyczną, którą możemy uwypuklić, biorąc jednostki
> > > znaczeniowe w nawiasy:
> > >
> > > (suma (kwadraty (początkowe 7 liczby-pierwsze)))
> > >
> > > Teraz wystarczy nam wyjaśnić, co to jest (suma elementów)
> > > czym są (kwadraty elementów), co to jest (początkowe N elementy)
> > > i czym są liczby-pierwsze.
> > >
> > > To jest kod, który bardzo łatwo się komponuje, i który
> > > bardzo łatwo się czyta, testuje i analizuje (I nie trzeba wyjaśniać,
> > > gdzie należy szukać wyniku)
> > >
> > > wiadomo, że (o ile definicje pojęć są takie, jakich byśm oczekiwali) wyrażenie
> > >
> > > (suma (kwadraty (początkowe 7 liczby-pierwsze)))
> > >
> > > jest równoważne wyrażeniu
> > >
> > > (suma (kwadraty '(2 3 5 7 11 13)))
> > >
> > > które jest równoważne wyrażeniu
> > >
> > > (suma '(4 9 25 49 121 169))
> > >
> > > i tak dalej.
> > >
> > lol ale mozesz podac ten kod w lispie w postaci takiej kompletnosci jak ten
przyklad w pseudkodzie, by to rzeczywiscie porownac?
> >
> > bo to jest raczej istotnie
> >
> >
> > w c taki programik nie wyglada zbyt tragicznie
> >
> >
> > int PoliczSumeParuPoczatkowychLiczbPierwszych(int ilu)
> > {
> >
> > int dodano_pierwszych =0;
> > int suma = 0;
> >
> > for(int i=0;;i++)
> > {
> > if(jest_liczba_pierwsza(i))
> > {
> > suma+=i*i;
> > dodano_pierwszych++;
> > if(dodano_pierwszych==ilu) return suma;
> > }
> > }
> > }
> >
> > to ze nie wydziela on etapow na podej pierwsze, podnies do kwadratu zsumuj wynika
raczej z tego ze pisze sie to tak by dzialalo szybko.. jak ktos sie nie upiera by
bylo tak szybko moze podzielic na te fazy
> >
> >
> > chetnie bym zobaczyl taki kompletny progamik w tym lispie scheme czy co to tam
jest
>
> Ogólnie derywację tego programu mam dość dogłębnie opisaną
> w pierwszym rozdziale "Pamphletu":
> https://github.com/panicz/pamphlet/raw/master/pamphl
et.pdf
>
> W praktyce zapisałbym go raczej np. tak (jeżeli język
> wspierałby leniwą ewaluację):
>
> (sum (map square (initial 7 (only prime? numbers))))
>
> gdzie "map", "only" i "initial" są zdefiniowane tak:
>

jakos nie wyglada mi to na prostsze niz wersja w c

a co to jest tam wyzej sum square (inty?) prime? (funkcja?) i numbers (???)

nie wyglada to na prostsze od c (dlugie jakies) a w to ze to bedzie tak szybkie tez
nie do konca wierze ale powiedzmy ze to mniej istotne, przydaloby sie jednak by bylo
choc prostsze a nie wyglada

sam ten kod w c chyab w sumie mozna napisac prsciej


int PoliczSumeParuPoczatkowychLiczbPierwszych(int ilu)
{
int i = 0, dodano = 0, suma = 0;

for(;;)
if(jest_liczba_pierwsza(++i))
{
suma += i*i ;
if(++dodano==ilu) return suma;
}
}

to i tak jest przydlugie, niepodobaja mi sie zwlaszcza te niepotrzebne jakby
deklaracje.. no i jest trioche kryptyczne, no ale tak to sie pisze w c


> (define (map f list)
> (if (null? list)
> '()
> ;else
> (cons (f (first list)) (map f (rest list)))))
>
> (define (initial n elements)
> (if (= n 0)
> '()
> ;else
> (cons (first elements) (initial (- n 1) (rest elements))))))
>
> (define (only satisfying? elements)
> (if (null? elements)
> '()
> ;else
> (if (satisfying? (first elements))
> (cons (first elements) (only satisfying? (rest elements)))
> ;else
> (only satisfying? (rest elements)))))
>
> W Haskellu może jest nieco zwięźlej i czytelniej:
>
> map f [] = []
> map f (h:t) = (f h):(map f t)
>
> initial 0 elements = []
> initial n (first:rest) = first:(initial (n-1) rest)
>
> only satisfying [] = []
> only satisfying (first:rest) = if (satisfying first)
> then first:(only satisfying rest)
> else only satisfying rest
>
> Teraz, w języku z leniwą ewaluacją możemy zbudować nieskończoną listę liczb:
>
> (define (numbers-from n)
> (cons n (numbers-from (+ n 1))))
>
> (define numbers (numbers-from 0))
>
> albo w Haskellu:
>
> numbersFrom n = n:(numbersFrom (n+1))
>
> numbers = numbersFrom 0
>
> Sumę definiujemy następująco:
>
> (define (sum list)
> (if (null? list)
> 0
> ;else
> (+ (first list) (sum (rest list)))))
>
> albo w Haskellu:
>
> sum [] = 0
> sum (first:rest) = first + (sum rest)
>
> W jezyku bez leniwej ewaluacji jest nieco ciężej (ten wariant jest
> opisany w Pamphlecie)
>
> Jeżeli idzie o "wydajność", to kompilator Haskella wspiera technikę
> kompilacji zwaną "fuzją" albo "deforestacją", i efektywnie wynikowy
> kod będzie z grubsza równoważny temu, co Ty napisałeś (nie będą
> tworzone żadne dodatkowe struktury w pamięci, tylko będzie pętla
> iterująca po jakichś tam zmiennych)