Skip to content

Commit d6d6438

Browse files
mnordahlmnordahl
committed
Big update on LaTeX slides, still WIP
1 parent b7cd03d commit d6d6438

13 files changed

+1360
-567
lines changed

‎.vscode/settings.json

+5-1
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,8 @@
11
{
22
"editor.formatOnSave": false,
3-
"latex-workshop.latex.recipe.default": "latexmk (xelatex)"
3+
"latex-workshop.latex.recipe.default": "latexmk (xelatex)",
4+
"latex-workshop.latex.search.rootFiles.exclude": [
5+
"**/latex.tex"
6+
],
7+
"latex-workshop.latex.rootFile.useSubFile": false
48
}

‎lab-material/latex_new/oformaterad_text.txt

+158
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,158 @@
1+
2+
3+
4+
Effektivitet i Scala: Sorteringsalgoritmer
5+
Fiktiv Författare
6+
12 september 2024
7+
8+
Notera
9+
Denna artikel är primärt genererad med hjälp av AI-verktyg, och se-
10+
dan manuellt kontrollerad och justerad. Alla data och mätningar är
11+
påhittade för övningsändamål.
12+
13+
1 Introduktion
14+
Scala är ett populärt språk som kombinerar funktionell och objektoriente-
15+
rad programmering. I denna artikel utvärderar vi effektiviteten hos olika
16+
sorteringsalgoritmer när de används i Scala. Speciellt fokuserar vi på sorte-
17+
ringsalgoritmerna QuickSort och MergeSort.
18+
19+
2 O-notation
20+
Innan vi börjar prata om algoritmers tidseffektivitet behöver vi förstå så
21+
kallad O-notation. O-notation (ibland kallad “stora O-notation” eller “big
22+
O notation” på engelska) är ett sätt att beskriva hur effektiv en algoritm
23+
är när det gäller exekveringstid, beroende på mängden data som algoritmen
24+
hanterar – så kallad tidskomplexitet. Den används ofta inom datavetenskap
25+
för att klassificera algoritmer baserat på deras prestanda, särskilt för stora
26+
inmatningsstorlekar.
27+
O-notationen uttrycker hur algoritmens tid växer som en funktion av
28+
storleken på indata, vanligtvis betecknad som n. Till exempel, om en algoritm
29+
har en tidskomplexitet på O(n), betyder det att tiden det tar att utföra
30+
algoritmen ökar linjärt med storleken på indata. O:et uttalas ofta som “ordo”,
31+
alltså “ordo n” för O(n) eller “ordo n log n” för O(n log n).
32+
33+
1
34+
35+
2.1 Vanliga O-klasser
36+
Här är några av de vanligaste O-notationerna och vad de representerar:
37+
38+
O(1) Konstant tid – Algoritmen tar samma tid oavsett storleken
39+
på indata.
40+
O(n) Linjär tid – Tiden ökar direkt proportionellt mot storleken
41+
på indata. En dubbling av indata leder till en dubbling av
42+
exekveringstiden.
43+
O(log n) Logaritmisk tid – Tiden ökar mycket långsamt när indata
44+
växer. Vanligt i effektiva sökalgoritmer.
45+
O(n log n) Linjär-logaritmisk tid – Vanligt för många effektiva sorte-
46+
ringsalgoritmer, som exempelvis MergeSort.
47+
O(n2) Kvadratisk tid – Tiden växer kvadratiskt med indata; of-
48+
ta sett i enklare sorteringsalgoritmer som Bubble Sort. En
49+
dubbling av indata leder till en fyrdubbling av exekverings-
50+
tiden.
51+
O(2n) Exponentiell tid – Tiden växer mycket snabbt med storle-
52+
ken på indata; vanligt i vissa rekursiva algoritmer.
53+
54+
2.2 Exempel
55+
Anta att vi har en sorteringsalgoritm som tar en lista med n tal och jämför
56+
varje tal med varje annat tal för att avgöra ordningen. Denna algoritm skulle
57+
ha en tidskomplexitet på O(n2) eftersom varje element (n stycken) jämförs
58+
med alla andra element (n stycken)1.
59+
O-notationen hjälper oss att förstå och förutsäga hur algoritmer beter
60+
sig när datamängden växer, och är därför ett ovärderligt verktyg vid val av
61+
algoritmer och datastrukturer.
62+
63+
3 Sorteringsalgoritmer
64+
Sortering är en grundläggande operation inom datavetenskap, och olika al-
65+
goritmer har olika prestanda beroende på data och sammanhang. Två av de
66+
vanligaste algoritmerna är QuickSort och MergeSort.
67+
68+
1Produkten blir egentligen n · (n − 1), men konstanta värden ignoreras i O-notation
69+
eftersom de inte spelar någon roll när n går mot ett stort värde.
70+
71+
2
72+
73+
3.1 Jämförelse av QuickSort och MergeSort
74+
QuickSort är en snabb sorteringsalgoritm som fungerar bra i genomsnitts-
75+
fallet med tidskomplexiteten O(n log n). Den kan dock prestera dåligt i det
76+
värsta fallet, med en tidskomplexitet på O(n2), om pivotvalet är ogynnsamt.
77+
MergeSort, å andra sidan, har alltid en tidskomplexitet på O(n log n), vilket
78+
gör den stabilare men ibland långsammare på grund av dess behov av extra
79+
minnesutrymme.
80+
I tabell 1 nedan jämförs prestandan hos QuickSort och MergeSort för
81+
olika indata. Se Appendix A för implementationen i Scala. (Notera igen att
82+
datan är påhittad för övningsändamål.)
83+
84+
Algoritm Indatastorlek (n) Indatatyp Tid (µs) Minne (MB)
85+
QuickSort 1000 Slumpmässig 12 5
86+
QuickSort 1000 Sorterad 1 5
87+
QuickSort 1000 Omvänd 30 5
88+
QuickSort 10000 Slumpmässig 150 5
89+
QuickSort 10000 Sorterad 2 5
90+
QuickSort 10000 Omvänd 450 5
91+
QuickSort 100000 Slumpmässig 1800 5
92+
QuickSort 100000 Sorterad 10 5
93+
QuickSort 100000 Omvänd 9000 5
94+
MergeSort 1000 Slumpmässig 20 10
95+
MergeSort 1000 Sorterad 20 10
96+
MergeSort 1000 Omvänd 20 10
97+
MergeSort 10000 Slumpmässig 200 10
98+
MergeSort 10000 Sorterad 200 10
99+
MergeSort 10000 Omvänd 200 10
100+
MergeSort 100000 Slumpmässig 2500 10
101+
MergeSort 100000 Sorterad 2500 10
102+
MergeSort 100000 Omvänd 2500 10
103+
Tabell 1: Jämförelse av QuickSort och MergeSort för olika indatatyper och
104+
-storlekar i Scala. Tid mäts i microsekunder och minnesanvänding i Mega-
105+
byte. “Omvänd” betyder att datan är sorterad i omvänd ordning, vilket är
106+
värstafallet för QuickSort.
107+
108+
Samma data presenteras grafiskt i figur 1 och 2.
109+
110+
3
111+
112+
[Figur - graf]
113+
Figur 1: Exekveringstid för de två sorteringsalgoritmerna QuickSort och Mer-
114+
geSort i Scala. För båda algoritmerna plottas tre olika indatatyper separat:
115+
Slumpmässig, sorterat och omvänt sorterad indata. (Linjär skala)
116+
117+
[Figur - graf]
118+
Figur 2: Exekveringstid för de två sorteringsalgoritmerna QuickSort och Mer-
119+
geSort i Scala. För båda algoritmerna plottas tre olika indatatyper separat:
120+
Slumpmässig, sorterat och omvänt sorterad indata. (Logaritmisk skala)
121+
122+
4
123+
124+
4 Matematisk analys av algoritmer
125+
Den matematiska analysen av dessa algoritmer kan göras med hjälp av deras
126+
tidskomplexitet. För QuickSort är den förväntade tidskomplexiteten:
127+
128+
TQ(n) = O(n log n)
129+
130+
Medan för MergeSort har vi:
131+
132+
TM (n) = O(n log n)
133+
134+
De har alltså samma tidskomplexitet i det genomsnittliga fallet. Trots
135+
liknande teoretisk prestanda kan dock det praktiska utförandet variera be-
136+
roende på storlek och typ av indata, som vi såg i tabell 1 och figurerna 1
137+
och 2.
138+
139+
5 Slutsats
140+
Vi har undersökt två olika sorteringsalgoritmer i Scala och jämfört deras
141+
prestanda. Resultaten visar att valet av algoritm kan ha en betydande på-
142+
verkan på programmets effektivitet. Genom att förstå dessa skillnader kan
143+
utvecklare fatta mer informerade beslut när de designar och optimerar sina
144+
program.
145+
146+
147+
148+
5
149+
150+
151+
152+
A Implementation i Scala
153+
154+
I kodlistning 1 nedan är ett exempel på en implementation av QuickSort och
155+
MergeSort i Scala:
156+
Listing 1: Scala-program med implementation av QuickSort och MergeSort.
157+
158+
[Inkludera filen sort.scala]

‎lab-material/latex_new/plot_sort_linear.png

79.9 KB
Loading

‎lab-material/latex_new/plot_sort_log.png

117 KB
Loading

‎lab-material/latex_new/plothelp.py

+61
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,61 @@
1+
import matplotlib.pyplot as plt
2+
import pandas as pd
3+
4+
# Creating a DataFrame with the faked data
5+
data = {
6+
"Algorithm": ["QuickSort"] * 9 + ["MergeSort"] * 9,
7+
"Input Size": [1000 * 10**i for i in range(3) for _ in range(3)] * 2,
8+
"Input Type": ["Random", "Sorted", "Reversed"] * 6,
9+
"Time (ms)": [
10+
12,
11+
1,
12+
30,
13+
150,
14+
2,
15+
450,
16+
1800,
17+
10,
18+
9000,
19+
20,
20+
20,
21+
20,
22+
200,
23+
200,
24+
200,
25+
2500,
26+
2500,
27+
2500,
28+
],
29+
"Memory (MB)": [5] * 9 + [10] * 9,
30+
}
31+
32+
df = pd.DataFrame(data)
33+
34+
# Plotting the data
35+
plt.figure(figsize=(10, 6))
36+
37+
# Plot time vs. input size for each algorithm and input type
38+
input_types = df["Input Type"].unique()
39+
for algo in df["Algorithm"].unique():
40+
for input_type in input_types:
41+
df_filtered = df[(df["Algorithm"] == algo) & (df["Input Type"] == input_type)]
42+
plt.plot(
43+
df_filtered["Input Size"],
44+
df_filtered["Time (ms)"],
45+
marker="o",
46+
linestyle="-",
47+
label=f"{algo} - {input_type}",
48+
)
49+
50+
# Enhancing the plot
51+
plt.xlabel("Input Size (n)")
52+
plt.ylabel("Time (ms)")
53+
plt.title("Comparison of QuickSort and MergeSort Performance by Input Type")
54+
# plt.xscale("log") # Using logarithmic scale for input size
55+
# plt.yscale("log") # Using logarithmic scale for time
56+
plt.grid(True, which="both", linestyle="--", linewidth=0.5)
57+
plt.legend()
58+
plt.tight_layout()
59+
60+
# Display the plot
61+
plt.show()

‎lab-material/latex_new/sort.scala

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
object SortComparison {
2+
def quickSort(arr: Array[Int]): Array[Int] = {
3+
if (arr.length <= 1) arr
4+
else {
5+
val pivot = arr(arr.length / 2)
6+
Array.concat(
7+
quickSort(arr.filter(_ < pivot)),
8+
arr.filter(_ == pivot),
9+
quickSort(arr.filter(_ > pivot))
10+
)
11+
}
12+
}
13+
14+
def mergeSort(arr: Array[Int]): Array[Int] = {
15+
if (arr.length <= 1) arr
16+
else {
17+
val (left, right) = arr.splitAt(arr.length / 2)
18+
val sortedLeft = mergeSort(left)
19+
val sortedRight = mergeSort(right)
20+
merge(sortedLeft, sortedRight)
21+
}
22+
}
23+
24+
private def merge(left: Array[Int], right: Array[Int]): Array[Int] = {
25+
(left, right) match {
26+
case (Array(), _) => right
27+
case (_, Array()) => left
28+
case (l, r) =>
29+
if (l.head < r.head) l.head +: merge(l.tail, r)
30+
else r.head +: merge(l, r.tail)
31+
}
32+
}
33+
}

‎lab-material/latex_new/sort_scala.tex

+110
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,110 @@
1+
\documentclass[a4paper,12pt]{article} % Dokumentklass: artikel, A4, 12 pt
2+
% [a4paper,12pt] är valfria parametrar
3+
% och kan tas bort
4+
5+
% Det finns flera olika LaTeX-kompilatorer. Två vanliga är pdfLaTeX och XeLaTeX.
6+
% - pdfLaTeX är standard för de flesta dokument och är snabb och pålitlig,
7+
% men har begränsat Unicode-stöd.
8+
% - XeLaTeX erbjuder fullt Unicode-stöd och möjligheten att använda
9+
% systemtypsnitt, vilket gör det lämpligt för internationella dokument.
10+
11+
12+
% Endast för pdfLaTeX. Behövs inte för XeLaTeX, eftersom den använder
13+
% Unicode och systemets redan installerade typsnitt (fonts).
14+
\usepackage[utf8]{inputenc} % UTF-8 teckenkodning för pdfLaTeX
15+
\usepackage[T1]{fontenc} % Teckenuppsättning för pdfLaTeX
16+
17+
% Behövs för både för pdfLaTeX och XeLaTeX
18+
\usepackage[swedish]{babel} % Svensk språkstil och avstavning
19+
20+
% Om du vill använda särskillda typsnitt med XeLaTeX, använd följande:
21+
% \usepackage{fontspec} % För att kunna använda typsnitt
22+
% \setmainfont{Latin Modern Roman} % Sätt huvudtypsnittet
23+
24+
% Övriga paket
25+
\usepackage{graphicx} % Hantera bilder
26+
\usepackage{tcolorbox} % Färgade ramar/lådor
27+
% \usepackage{amsmath} % Mer avancerat matematikstöd,
28+
% % t.ex. flerradiga ekvationer,
29+
% % matriser, anpassade operatorer
30+
% % och bättre layout, men behövs
31+
% % inte för detta dokument
32+
33+
% För att inkludera källkod kan man använda 'verbatim',
34+
% men 'listings' ger ofta bättre resultat
35+
\usepackage{listings} % Källkodshantering
36+
37+
% Konfigurera hur kodlistningar ska visas
38+
\lstset{
39+
language=Scala, % Använder Scala för syntaxmarkering
40+
basicstyle=\ttfamily\footnotesize, % Använder monospace teckensnitt
41+
% samt mindre textstorlek
42+
keywordstyle=\color{blue}\bfseries, % Färglägger nyckelord
43+
stringstyle=\color{orange}, % Färglägger strängar i orange
44+
commentstyle=\color{gray}\itshape, % Färglägger kommentarer
45+
showstringspaces=false, % Visar inte mellanslag i strängar
46+
numbers=left, % Visar radnummer till vänster
47+
numberstyle=\tiny\color{gray}, % Gör radnummer små och grå
48+
stepnumber=1, % Visar varje radnummer
49+
tabsize=2, % Antal mellanslag i en tabb
50+
breaklines=true, % Radbrytning vid behov
51+
frame=single, % Ram runt koden
52+
columns=fullflexible, % Flexibel bredd på bokstäverna
53+
keepspaces=true, % Behåller mellanslag i koden
54+
fontadjust=true, % Autojusterar fontstorlek vid behov
55+
}
56+
57+
58+
\usepackage{enumitem} % Anpassade listor
59+
% Anpassa hur 'description' listor ser ut
60+
\setlist[description]{
61+
leftmargin=2.3cm, % Vänstermarginal
62+
rightmargin=1cm, % Högermarginal
63+
labelindent=1cm, % Etikettindrag
64+
labelwidth=1cm, % Etikettbredd
65+
align=right, % Högerjustera etikett
66+
labelsep=3mm % Avstånd mellan etikett och beskrivning
67+
}
68+
69+
70+
\title{What is the meaning of life?}
71+
\author{Unnamed Author}
72+
\date{\today}
73+
74+
\begin{document}
75+
76+
\maketitle % Skriv ut titel, författare och datum
77+
78+
\[ 42 \]
79+
80+
Resten av dokumentet här!
81+
82+
% Du kommer behöva söka upp information om flera kommandon. Ta hjälp av
83+
% kursmaterialet och internet. Nedan följer lite tips:
84+
%
85+
% - För att forcera en ny sida, använd \newpage
86+
% - Kolla up skillnaden mellan \emph, \textit och \textbf
87+
% - För att inkludera en figur, använd figure och includegraphics
88+
% - För att skriva kod kan man använda verbatim och verbatiminput, men...
89+
% - ... det blir snyggare med listings-paketet
90+
% - LaTeX numrerar automatiskt rubriker och figurer
91+
% - Bilagor numreras med bokstäver, och heter "Appendix" på engleska
92+
% - Med \ref kan man referera till saker som är märkta med en \label,
93+
% t.ex. figurer, tabeller, ekvationer och sektioner
94+
% - Fina lådor kan skapas med:
95+
% \begin{tcolorbox}[title=Min titel här]
96+
% Text...
97+
% \end{tcolorbox}
98+
% - Det finns tre huvudtyper av listor: itemize, enumerate och description
99+
% - Med tecknet ~ skriver man ett hårt mellanslag, som inte bryts över
100+
% radslut. Användbart t.ex. för att skriva "figur 1" utan att ettan
101+
% hamnar på nästa rad.
102+
% - Figurer och tabeller kan placeras med [h], [t], [b] och [p] för att
103+
% tvinga LaTeX att placera dem 'here', 'top', 'bottom' ner eller på en
104+
% egen sida, 'page'. \begin{table}[b] ...
105+
% - Skriv figurtexter med \caption
106+
% - Skriv fotnötter med \footnote{Text här}, där du vill ha fotnoten.
107+
% Fotnotstexten hamnar automatiskt längst ner på sidan.
108+
109+
110+
\end{document}

0 commit comments

Comments
 (0)