An Algorithm for: Explaining Algorithms

1
An Algorithm forExplaining Algorithms

• Tomasz Müldner

2
Vision what is where by looking
Visualization the power or process of forming a
mental image of vision of something not actually
present to the sight You have 10s to find this
image
3
Dijkstra feared

• permanent mental damage for most students
  exposed to program visualization software

4
Contents

• Preface
• Introduction to Algorithm Visualization, AV
• Examples of AV
• Algorithm Explanation, AE
• Examples of AE
• Conclusions Future Work

5
Preface

• Under Construction
• Early version
• Invitation to collaborate

6
Al-Khorezmi -gt Algorithm

• The ninth century
• the chief mathematician in the academy of
  sciences in Baghdad

7
Introduction to AV

• AV uses multimedia
• Graphics
• Animation
• Auralization
• to show abstractions of data

8
Examples of AV

• Multiple Sorting
• Duke
• More
• AIA

9
Typical Approach in AV

• take the description of the algorithm
• graphically represent data in the code using
  bars, points, etc.
• use animation to represent the flow of control
• show the animated algorithm and hope that the
  learner will now understand the algorithm

10
Problems with AV

• Graphical language versus text
• Low level of abstraction (code stepping)
• Emphasis on meta-tools
• Students perform best if they are asked to
  develop visualizations
• no attempt to visualize or even suggest essential
  properties, such as invariants
• Very few attempts to visualize recursive
  algorithms

11
Introduction to AE

• systematic procedure to explain algorithms an
  algorithm for explaining algorithms
• Based on findings from Cognitive Psychology,
  Constructivism Theory, Software Engineering
• visual representation is used to help reason
  about the textual representation
• Use multiple abstraction levels to focus on
  selected issues
• Designed by experts

12
Goals of AE

• Understanding of both, what the algorithm is
  doing and how it works
• Ability to justify the algorithm correctness (why
  the algorithm works)
• Ability to code the algorithm in any programming
  language
• Understanding of time complexity of the algorithm

13
Requirements for AE

• The algorithm is presented at several levels of
  abstraction
• Each level of abstraction is represented by the
  abstract data model and pseudocode
• The design supports active learning
• The design helps to understand time complexity

14
Levels of Abstraction

• public static void selection(List aList)
• for (int i 0 i lt aList.size() i)
• swap(smallest(i, aList) , i, aList)
• Primitive operations can be
• Explained at different abstraction level
• inlined

15
AE Catalogue Entries

• Multi-leveled Abstract Algorithm Model
• Example of an abstract implementation of the
  Abstract Algorithm Model
• Tools that can be used to help to predict the
  algorithm complexity
• Questions for students

16
MAK

• Uses multimedia
• Graphics
• Animation
• Auralization
• to show abstractions of data
• Interacts with the student e.g. by providing
  post-tests
• Uses a student model for adaptive behavior

17
MAK
Selection Sort
Insertion Sort
Quick Sort
18
Selection Sort Abstract Data Model

• Sequences of elements of type T, denoted by
  SeqltTgt with a linear order defined in one of
  three ways
• type T supports the function int
  compare(const T x)
• type T supports the lt relation
• there is a global function int
  comparator(const T x, const T y)

19
Selection Sort Top level of Abstraction

• Abstract Data Model
• Type T also supports the function
• swap(T el1, T el2)
• The following operations on SeqltTgt are available
• a sequence t can be divided into prefix and
  suffix
• the prefix can be incremented (which will
  decrement the suffix)
• first(suffix)
• T smallest(seqltTgt t, Comparator comp)

20
Selection Sort Top level of Abstraction
Pseudocode void selection(SeqltTgt t, Comparator
comp) for(prefix NULL prefix ! t
increment prefix by one element) swap(
smallest(suffix, comp), first(suffix) )
21
Visualization
void selection(SeqltTgt t, Comparator comp)
for(prefix NULL prefix ! t increment prefix
by one element) swap( smallest(suffix,
comp), first(suffix) )
List two invariants
22
void selection(SeqltTgt t, Comparator comp)
for(prefix NULL prefix ! t increment prefix
by one element) swap( smallest(suffix,
comp), first(suffix) )
List two invariants
23
Selection Sort Low level of Abstraction
Pseudocode T smallest(SeqltTgt t, Comparator
comp) smallest first element of t
for(traverse t forward) if(smallest
current are out of order) smallest
current
24
T smallest(SeqltTgt t, Comparator comp)
smallest first element of t for(traverse t
forward) if(smallest current out of
order) smallest current
Visualization
25
Abstract Implementation

• The Abstract Iterator Implementation Model
  assumes
• There is an Iterator type, where iterations are
  performed over a half-closed interval a, b)
• Iterator type supports the following operations
• two iterators can be compared for equality and
  inequality
• there are operations to provide various kinds of
  traversals for example forward and backward
• an iterator can be dereferenced to access the
  object it points to

26
Abstract Implementation

• The Abstract Iterator Implementation Model
  assumes (Cont.)
• The domain SeqltTgt supports SeqltTgtIterator
• The following two operations are defined on
  sequences
• Iterator t.begin()
• Iterator t.end()

27
Selection Sort Abstract Implementation
Pseudocode void selection(SeqltTgt t, Comparator
comp) SeqltTgtIterator eop // end of
prefix for(eop t.begin() eop ! t.end()
eop) swap(smallest(eop, t.end(), comp),
eop) T smallest(SeqltTgt t, Comparator comp)
Iterator small t.begin() Iterator current
for(current t.begin() current ! t.end()
current) if(value of current lt value of
small) small current return value of
small
28
void selection(T x, T const end, int
comparator(const T, const T)) T eop
for(eop x eop ! end eop) swap(
smallest(eop, end, comparator), eop ) T
smallest(T const first, T const last, int
comparator(const T, const T) ) T small
first T current for(current first
current ! last current) if(comparator(
current, small) lt 0) small current return
s
void selection(SeqltTgt t, Comparator comp)
SeqltTgtIterator eop // end of prefix
for(eop t.begin() eop ! t.end() eop)
swap(smallest(eop, t.end(), comp), eop) T
smallest(SeqltTgt t, Comparator comp) Iterator
small t.begin() Iterator current
for(current t.begin() current ! t.end()
current) if(value of current lt value of
small) small current return value of
small
C implementation
29
typedef struct int a int b T define
SIZE(x) (sizeof(x)/sizeof(T)) T x 1, 2,
3, 7, 2, 4, 11, 22 define S SIZE(x) int
comparator1(const T x, const T y) if(x.a
y.a) return 0 if(x.a lt y.a) return -1
return 1 int comparator2(const T x, const T y)
if(x.a y.a) if(x.b y.b) return 0
else if(x.b lt y.b) return -1 else return
1 if(x.a lt y.a) return -1 return 1
int main() printf("original sequence\n")
show(x, S) selection(x, xS, comparator1)
printf("sequence after first sort\n") show(x,
S) selection(x, xS, comparator2)
printf("sequence after second sort\n") show(x,
S)
30
template lttypename Iterator, typename Predicategt
void selection(Iterator first, Iterator last,
Predicate compare) Iterator eop
for(eop first eop ! last eop)
swap(min_element(eop, last, compare), eop)
void selection(SeqltTgt t, Comparator comp)
SeqltTgtIterator eop // end of prefix
for(eop t.begin() eop ! t.end() eop)
swap(smallest(eop, t.end(), comp), eop) T
smallest(SeqltTgt t, Comparator comp) Iterator
small t.begin() Iterator current
for(current t.begin() current ! t.end()
current) if(value of current lt value of
small) small current return value of
small
C implementation
31
public static void selection(List aList,
Comparator aComparator) for (int i 0 i lt
aList.size() i) swap(smallest(i, aList,
aComparator) , i, aList) private static int
smallest(int from, List aList, Comparator aComp)
int minPos from int count from for
(ListIterator i aList.listIterator(from)
i.hasNext() count) if (aComp.compare(i.next(
), aList.get(minPos)) lt 0) minPos
count return minPos
void selection(SeqltTgt t, Comparator comp)
SeqltTgtIterator eop // end of prefix
for(eop t.begin() eop ! t.end() eop)
swap(smallest(eop, t.end(), comp), eop) T
smallest(SeqltTgt t, Comparator comp) Iterator
small t.begin() Iterator current
for(current t.begin() current ! t.end()
current) if(value of current lt value of
small) small current return value of
small
Java implementation
32
Algorithm Complexity

• Three kinds of tools
• to experiment with various data sizes and plot a
  function that approximates the time spent on
  execution with this data.
• a visualization that helps to carry out time
  analysis of the algorithm
• questions regarding the time complexity

33
Post Test

• What is the number of comparisons and swaps
  performed when selection sort is executed for
• sorted sequence
• sequence sorted in reverse
• What is the time complexity of the function
  isSorted(t), which checks if t is a sorted
  sequence?
• Hand-execute the algorithm for a sample set of
  input data of size 4.
• Hand-execute the next step of the algorithm for
  the specified state
• Whats the last step of the algorithm?
• There are two invariants of this algorithm which
  one is essential for the correctness of
  swap(smallest(), eop), and why.
• do it yourself

34
Quick Sort
Pseudocode void quick(SeqltTgt t, Comparator
comp) if( size(t) lt 1) return pivot
choosePivot(t) divide(pivot, t, t1, t2, t3,
comp) quick(t1, comp) quick(t3, comp)
concatenate(t, t1, t2, t3)
35
(No Transcript)
36
(No Transcript)
37
(No Transcript)
38
Future Work

• evaluation (eye movement?)
• student model
• different visualizations
• more complex algorithms
• Algorithmic design patterns
• generic approach
• MAK