Perl 6

Intro Några predikat Generera och testa Exempelprogram: Sortera gener 

Perl 6 

Today, Pugs stands as the most 

complete Perl 6 implementation 

(although others are on the way) and 

as a test bed for tests and working out 

design details. 

— Randall Schwartz 

Från pugscode.org: 

”Pugs is an implementation of Perl 6, written in 

Haskell. It aims to implement the full Perl6 

specification, ...”


Kodexempel 

• Se ”kursmaterial” på kurshemsidan. 

• eller /info/progp06/prolog. 

• Där finns nu starwars.pl, tree.pl, 

mm.


Labbinfo 

• Lab 3: På tisdag, 10/10, kl 8–10. 

• Lab 4: Måndagen veckan därpå, 

16/10, 8–10.


Schemat framöver 

10/10 F12 Särskild genomgång för lab 2? 

25/10 F13 Differenslistor, avslutning prolog 

26/10 F14 Syntaxanalys 



Alexander Baltatzis: 

6/11 AF1 C-programmering 

13/11 AF2 

14/11 AF3 Internetprogrammering 

29/11 AF4


Senast 

• Negationer 

virginBirth(X) :mother(_, 

X), \+ father(_, X). 

| ?- virginBirth(X). 

X = anakin ? n 

no


Senast 

• Negationer 

virginBirth(X) :mother(_, 

X), \+ father(_, X). 

| ?- virginBirth(X). 

X = anakin ? n 

no 

• Negationer kan ställa till det: Antagande om 

en sluten värld. 

likes(ann, pears). 

likes(bo, pears). 

| ?- likes(cia, pears). 

no 

| ?- \+ likes(X, pears). 

no


Senast 

• Snitt (eng: cut) begränsar ”backtracking”: 

Har vi hittat en lösning så är det bra. 

permSort(X, Y) :permutation(X, 

Y), ordered(Y), !. 

permutation 

permSort 

ordered 

!


Senast 





permutation 

permSort 

ordered 

• Gröna snitt: Påverkar inte programmets 

funktion. 

!


Senast 





permutation 

permSort 

ordered 

• Gröna snitt: Påverkar inte programmets 

funktion. 

• Röda snitt: Förändrar programmets logiska 

läsning. 

!


• Fler predikat. 

• Några exempel. 

Idag 

• Programmeringsstil: Generera och testa. 

Används i lab 4 och 5.


• setof 

• bagof 

• findall 

Några predikat


setof 

| ?- setof(X, powerful(X), Ps).


setof 

| ?- setof(X, powerful(X), Ps). 

Ps = [dartVader,darthMaul,darthSidious, 

obiwan,quigon,yoda] ? 

yes


wealthy(jean). 

healthy(jean). 

healthy(joan). 

wealthy(jane). 

happy(X) :wealthy(X). 

happy(X) :healthy(X). 

bagof








bagof 

| ?- happy(X). 

X = jean ? n 

X = jane ? n 

X = jean ? n 

X = joan ? n 

no 

| ?- bagof(X, happy(X), L).








bagof 


X = jean ? n 

X = jane ? n 

X = jean ? n 

X = joan ? n 

no 

| ?- bagof(X, happy(X), L). 

L = [jean,jane,jean,joan] ? n 

no 

| ?-








bagof 


X = jean ? n 

X = jane ? n 

X = jean ? n 

X = joan ? n 

no 



no 

| ?- setof(X, happy(X), L). 

L = [jane,jean,joan] ? n 

no








bagof 


X = jean ? n 

X = jane ? n 

X = jean ? n 

X = joan ? n 

no 



no 

| ?- setof(X, happy(X), L). 

L = [jane,jean,joan] ? n 

no


bagof och setof med en fri parameter 

| ?- bagof(P, parent(P, C) , L). 

C = anakin, 

L = [schmi] ?




C = anakin, 

L = [schmi] ? n 

C = leia, 

L = [padme,anakin] ?




C = anakin, 

L = [schmi] ? n 

C = leia, 

L = [padme,anakin] ? n 

C = luke, 

L = [padme,anakin] ? n 

no


findall 

| ?- findall(P, parent(P, C) , L). 

L = [padme,padme,anakin,schmi,anakin] ? n 

no 

| ?-


findall 

| ?- findall(P, parent(P, C) , L). 

L = [padme,padme,anakin,schmi,anakin] ? n 

no 

| ?- findall(P, parent(P, C) , L), 

setof(M, member(M, L), Ms). 

L = [padme,padme,anakin,schmi,anakin], 

Ms = [anakin,padme,schmi] ? n 

no


Generera och testa 

• Programstruktur: 

searchProblem(X) :generate(X), 

testSolution(X). 

• Används i lab 4. 

• Läs avsnitt 5.1 i labbhäftet!


Exempelproblem: Bordsplacering 

• Antag k gäster runt ett långbord. 

• Vill undvika att placera vissa bredvid 

varandra. 

• Vissa par ska placeras bredvid varandra.


Huvudprogram 

bordsplacering(Personer, Villkor, Bord) :permutation(Personer, 

Placering), 

uppfyller(Villkor, Bord).


Huvudprogram 


Placering), 

uppfyller(Villkor, Bord). 

• Personer: [ann, bo, cia, ...] 

• Otillåtet par: o(ann, bo) 

• Intillsittande par: i(cia, dan)


Huvudprogram 


Placering), 




• Intillsittande par: i(cia, dan) 

uppfyller([], _).


Huvudprogram 


Placering), 





uppfyller([], _). 

uppfyller([i(A, B)|Cs], Pl) :intill(A, 

B, Pl), 

uppfyller(Cs, Pl).


Huvudprogram 


Placering), 





uppfyller([], _). 

uppfyller([i(A, B)|Cs], Pl) :intill(A, 

B, Pl), 

uppfyller(Cs, Pl). 

uppfyller([o(A, B)|Cs], Pl) :ejintill(A, 

B, Pl), 

uppfyller(Cs, Pl).


Probleminstans 

personer([ann, bo, cia, dan, eje, 

fia, gu, han, ia]). 

bivillkor([i(cia, dan), 

o(ann, bo), 

i(eje, bo), 

o(gu, han), 

o(ia, gu)]).






o(ann, bo), 

i(eje, bo), 

o(gu, han), 

o(ia, gu)]). 

| ?- personer(P), bivillkor(C), 

bordsplacering(P, C, Pl).






o(ann, bo), 

i(eje, bo), 

o(gu, han), 

o(ia, gu)]). 

| ?- personer(P), bivillkor(C), 

bordsplacering(P, C, Pl). 

C = [i(cia,dan),o(ann,bo),i(eje,bo), 

o(gu,han),o(ia,gu)], 

P = [ann,bo,cia,dan,eje,fia,gu,han,ia], 

Pl = [ann,cia,dan,bo,eje,gu,fia,han,ia] ? 

yes


Praktisk lösning? 

• Lösningsgenerering ej effektiv! 

• Jämförbar med ”permutation sort”. 

• Måste generera smartare!


Sudoku 

6 8 7 9 

1 2 8 

9 

6 2 4 

4 3 

3 7 6 

9 

7 3 1 

9 3 6 8 

Placera ut 

siffrorna 1 – 9 så 

att varje siffra 

återfinns endast 

en gång i varje 

rad, kolumn, och 

delkvadrat.


Ansats med generera/testa 

sudoku(S) :transform(S, 

ByColumn, BySubsquare), 

verifyLists(S), 

verifyLists(ByColumn), 

verifyLists(BySubsquare).


Ansats med generera/testa 

sudoku(S) :transform(S, 

ByColumn, BySubsquare), 

verifyLists(S), 

verifyLists(ByColumn), 

verifyLists(BySubsquare). 

verifyLists([]). 

verifyLists([L|Ls]) :verifyList(L), 

verifyLists(Ls). 

verifyList(L) :permutation([1,2,3,4,5,6,7,8,9], 

L).


transform([[X11,X12,X13,X14,X15,X16,X17,X18,X19], 

[X21,X22,X23,X24,X25,X26,X27,X28,X29], 

[X31,X32,X33,X34,X35,X36,X37,X38,X39], 

[X41,X42,X43,X44,X45,X46,X47,X48,X49], 

[X51,X52,X53,X54,X55,X56,X57,X58,X59], 

[X61,X62,X63,X64,X65,X66,X67,X68,X69], 

[X71,X72,X73,X74,X75,X76,X77,X78,X79], 

[X81,X82,X83,X84,X85,X86,X87,X88,X89], 

[X91,X92,X93,X94,X95,X96,X97,X98,X99]], 

[[X11,X21,X31,X41,X51,X61,X71,X81,X91], 

[X12,X22,X32,X42,X52,X62,X72,X82,X92], 

[X13,X23,X33,X43,X53,X63,X73,X83,X93], 

[X14,X24,X34,X44,X54,X64,X74,X84,X94], 

[X15,X25,X35,X45,X55,X65,X75,X85,X95], 

[X16,X26,X36,X46,X56,X66,X76,X86,X96], 

[X17,X27,X37,X47,X57,X67,X77,X87,X97], 

[X18,X28,X38,X48,X58,X68,X78,X88,X98], 

[X19,X29,X39,X49,X59,X69,X79,X89,X99]], 

[[X11,X12,X13, X21,X22,X23, X31,X32,X33], 

[X14,X15,X16, X24,X25,X26, X34,X35,X36], 

[X17,X18,X19, X27,X28,X29, X37,X38,X39], 

[X41,X42,X43, X51,X52,X53, X61,X62,X63], 

[X44,X45,X46, X54,X55,X56, X64,X65,X66], 

[X47,X48,X49, X57,X58,X59, X67,X68,X69], 

[X71,X72,X73, X81,X82,X83, X91,X92,X93], 

[X74,X75,X76, X84,X85,X86, X94,X95,X96], 

[X77,X78,X79, X87,X88,X89, X97,X98,X99]]).


Hur funkar det? 

• Testning snabbt (”är detta en sudoku?”)



• Testning snabbt (”är detta en sudoku?”) 

• Långsamt att lösa en sudoku!




• Långsamt att lösa en sudoku! 

• Klarar bara ett litet antal okända (klarar inte 

ICAs ”enkla” sudoku med 45 okända)






ICAs ”enkla” sudoku med 45 okända) 

• Kusoffsky: ”17 okända går på några 

sekunder”








sekunder” 

• Vad göra?








sekunder” 

• Vad göra? 

• Generera smartare!


Färga en karta 

• Sats: Varje planär graf kan färgas med fyra 

färger. 

• Alltså: Varje karta kan färgas med fyra 

färger. 

• Skriv ett program som färgar en karta! 

(Från Sterling-Shapiro: The Art of Prolog)


Datastruktur 

region(Area, AreaColor, NeighborColors). 

Exempelinstans: 

[region(a, A, [B,C,D]), 

region(b, B, [A, C, D]), 

region(c, C, [A,B,D,E,F]), 

region(d, D, [A,C, F]), 

region(e, E, [B, C, F]), 

region(f, F, [C, D, E])]


En bit av Europa 

map(europe, 

[region(portugal, P, [E]), 

region(spain, E, [F, P]), 

region(france, F, [E, I, S, B, G, L]), 

region(belgium, B, [F, H, L, G]), 

region(holland, H, [B, G]), 

region(germany, G, [F, A, S, H, B, L]), 

region(luxembourg,L,[F, B, G]), 

region(italy, I, [F, A, S]), 

region(switzerl, S, [F, I, A, G]), 

region(austria, A, [I, S, G])]) 

).


Programmet 

% colorMap(Map, ColorList) 

% För varje region: Välj en färg 

colorMap([],_). 

colorMap([Region|Regions], Colors) :colorRegion(Region, 

Colors), 

colorMap(Regions, Colors).


Programmet 

% colorMap(Map, ColorList) 

% För varje region: Välj en färg 

colorMap([],_). 

colorMap([Region|Regions], Colors) :colorRegion(Region, 

Colors), 

colorMap(Regions, Colors). 

% colorRegion(Region, ColorList) 

% En region tar en färg och kräver att grannregionerna 

% inte använder den färgen 

colorRegion(region(Name, 

Color, 

Neighbors), Colors) :select(Color, 

Colors, Colors1), %Generera 

members(Neighbors, Colors1). %Testa


Exempelkörning 

| ?- map(europe, M), 

colorMap(M, [red,blue,green,yellow]).




colorMap(M, [red,blue,green,yellow]). 

M = [region(portugal,red,[blue]),region(spain,blue,[red, 

egion(belgium,blue,[red,red,green,yellow]),region(hollan 

...]),region(luxembourg,green,[red,blue,yellow]),region( 

ion(...)] ? 

yes 

| ?-




colorMap(M, [red,blue,green,yellow]). 

M = [region(portugal,red,[blue]),region(spain,blue,[red, 

egion(belgium,blue,[red,red,green,yellow]),region(hollan 

...]),region(luxembourg,green,[red,blue,yellow]),region( 

ion(...)] ? 

yes 


colorMap(M, [red,blue,green]). 

no


Om programmet 

• Implementerar en snål algoritm.


Om programmet 

• Implementerar en snål algoritm. 

• Riskerar vara ineffektiv.


Om programmet 

• Implementerar en snål algoritm. 

• Riskerar vara ineffektiv. 

• Fler färger ⇒ snabbare


Exempelprogram: Sortera gener 

• Vitt skilda organismer har mycket lika 

genuppsättning




genuppsättning 

• Intressant detalj: Ordningen är delvis 

konserverad






konserverad 

• Betrakta ett genom: 

1 2 

3 

4 

5






konserverad 


1 2 

• Se genomet som en permutation av gener: 

3 

4 

(1, 2, 3, 4, 5) 

5






konserverad 


1 2 


• Liknande genom: 

3 

4 

(1, 2, 3, 4, 5) 

(1, 4, 3, 2, 5) 

5






konserverad 


1 2 


• Liknande genom: 

3 

4 

(1, 2, 3, 4, 5) 

(1, 4, 3, 2, 5) 

5


Ett beräkningsproblem 

• Antalet inversioner är proportionellt mot 

tiden sedan artdelningen.




tiden sedan artdelningen. 

• Hur många inversioner har krävts för att 

komma från ett genom till ett annat?






komma från ett genom till ett annat? 

• Heuristik: Plocka bort brytpunkter.







• Heuristik: Plocka bort brytpunkter. 

• Brytpunkt: När två intilliggande gener inte 

har närliggande tal 

1 4 3 2 5










1|4 3 2|5










1|4 3 2|5 

1 2 3 4 5


Heuristiken 

• Om n gener, lägg till 0 och n + 1: 

5, 4, 3, 2, 1 ⇒ 0, 5, 4, 3, 2, 1, 6


Heuristiken 


5, 4, 3, 2, 1 ⇒ 0, 5, 4, 3, 2, 1, 6 

• Om det finns en inversion som plockar bort 

två brytpunkter, ta den.


Heuristiken 


5, 4, 3, 2, 1 ⇒ 0, 5, 4, 3, 2, 1, 6 


två brytpunkter, ta den. 

• Annars, om det finns en inversion som 

plockar bort en brytpunkt, ta den.


Heuristiken 


5, 4, 3, 2, 1 ⇒ 0, 5, 4, 3, 2, 1, 6 




plockar bort en brytpunkt, ta den. 

• Iterera tills inga fler brytpunkter.


Heuristiken 


5, 4, 3, 2, 1 ⇒ 0, 5, 4, 3, 2, 1, 6 





• Iterera tills inga fler brytpunkter.


Heuristiken 


5, 4, 3, 2, 1 ⇒ 0, 5, 4, 3, 2, 1, 6 





• Iterera tills inga fler brytpunkter. 

Obs: Ej optimalt! 

Alltför beräkningskrävande att lösa optimalt


Huvudprogram 

sortByInversions(L, []) :countBreakpoints(L, 

N), N=0. 

sortByInversions(Perm, [NextPerm|StateList]) :removeBreakpoints(Perm, 

NextPerm), 

sortByInversions(NextPerm, StateList).


Huvudprogram 

sortByInversions(L, []) :countBreakpoints(L, 

N), N=0. 

sortByInversions(Perm, [NextPerm|StateList]) :removeBreakpoints(Perm, 

NextPerm), 

sortByInversions(NextPerm, StateList). 

removeBreakpoints(L, NextL) :findInversionTwo(L, 

NextL), !. 

removeBreakpoints(L, NextL) :findInversionOne(L, 

NextL).


Testfall 

Genom A: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 

Genom B: 9, 2, 1, 6, 5, 4, 3, 8, 7, 10


Testfall 

Genom A: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 

Genom B: 9, 2, 1, 6, 5, 4, 3, 8, 7, 10 

| ?- p4(X), inversions(X, N). 

.9.1........ 

...96.43.... 

.......9.7.. 

N = 3, 

X = [9,2,1,6,5,4,3,8,7,10] ? 

yes


Testfall 

Genom A: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 

Genom B: 9, 2, 1, 6, 5, 4, 3, 8, 7, 10 

| ?- p4(X), inversions(X, N). 

.9.1........ 

...96.43.... 

.......9.7.. 

N = 3, 

X = [9,2,1,6,5,4,3,8,7,10] ? 

yes 

9, 2, 1, 6, 5, 4, 3, 8, 7, 10 

1, 2, 9, 6, 5, 4, 3, 8, 7, 10 

1, 2, 3, 4, 5, 6, 9, 8, 7, 10 

1, 2, 3, 4, 5, 6, 7, 8, 9, 10


Om algoritmen 

• Exempel på ickedeterministisk 

programmering 

• Fungerar i praktiken

Perl 6

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?