An Algorithm for Explaining Algorithms Tomasz Mldner September

An Algorithm for: Explaining Algorithms Tomasz Müldner September 12 1

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 10 s to find this image September 12 2

Dijkstra feared… “…permanent mental damage for most students exposed to program visualization software …” September 12 3

Contents • • • Preface Introduction to Algorithm Visualization, AV Examples of AV Algorithm Explanation, AE Examples of AE Conclusions & Future Work September 12 4

Preface • Under Construction • Early version • Invitation to collaborate September 12 5

Al-Khorezmi -> Algorithm The ninth century: • the chief mathematician in the academy of sciences in Baghdad September 12 6

Introduction to AV AV uses multimedia: – Graphics – Animation – Auralization to show abstractions of data September 12 7

Examples of AV • • Multiple Sorting Duke More AIA September 12 8

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 September 12 9

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 September 12 10

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 September 12 11

Goals of AE • • September 12 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 12

Requirements for AE • • September 12 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 13

Levels of Abstraction public static void selection(List a. List) { for (int i = 0; i < a. List. size(); ++i) swap(smallest(i, a. List) , i, a. List); } Primitive operations can be: • Explained at different abstraction level • inlined September 12 14

AE Catalogue Entries • • September 12 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 15

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 September 12 16

MAK Selection Sort Insertion Sort Quick Sort September 12 17

Selection Sort: Abstract Data Model Sequences of elements of type T, denoted by Seq<T> with a linear order defined in one of three ways: • type T supports the function int compare(const T x) • type T supports the “<” relation • there is a global function int comparator(const T x, const T y) September 12 18

Selection Sort: Top level of Abstraction Abstract Data Model Type T also supports the function swap(T el 1, T el 2) The following operations on Seq<T> are available: • a sequence t can be divided into prefix and suffix • the prefix can be incremented (which will decrement the suffix) • first(suffix) September 12 • T smallest(seq<T> t, Comparator comp) 19

Selection Sort: Top level of Abstraction Pseudocode void selection(Seq<T> t, Comparator comp) { for(prefix = NULL; prefix != t; increment prefix by one element) swap( smallest(suffix, comp), first(suffix) ); } September 12 20

Visualization void selection(Seq<T> t, Comparator comp) { for(prefix = NULL; prefix != t; increment prefix by one element) swap( smallest(suffix, comp), first(suffix) ); } List two invariants September 12 21

void selection(Seq<T> t, Comparator comp) { for(prefix = NULL; prefix != t; increment prefix by one element) swap( smallest(suffix, comp), first(suffix) ); } List two invariants September 12 22

Selection Sort: Low level of Abstraction Pseudocode T smallest(Seq<T> t, Comparator comp) { smallest = first element of t; for(traverse t forward) if(smallest & current are out of order) smallest = current; } September 12 23

Visualization September 12 T smallest(Seq<T> t, Comparator comp) { smallest = first element of t; for(traverse t forward) if(smallest & current out of order) smallest = current; } 24

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 September 12 25

Abstract Implementation The Abstract Iterator Implementation Model assumes (Cont. ): • The domain Seq<T> supports Seq<T>: : Iterator • The following two operations are defined on sequences: – Iterator t. begin() – Iterator t. end() September 12 26

Selection Sort: Abstract Implementation Pseudocode September 12 void selection(Seq<T> t, Comparator comp) { Seq<T>: : Iterator eop; // end of prefix for(eop = t. begin(); eop != t. end(); ++eop) swap(smallest(eop, t. end(), comp), eop); } T smallest(Seq<T> t, Comparator comp) { Iterator small = t. begin(); Iterator current; for(current = t. begin(); current != t. end(); ++current) if(value of current < value of small) small = current; return value of small; 27 }

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) < 0) small = current; return s; } void selection(Seq<T> t, Comparator comp) { C implementation September 12 Seq<T>: : Iterator eop; // end of prefix for(eop = t. begin(); eop != t. end(); ++eop) swap(smallest(eop, t. end(), comp), eop); } T smallest(Seq<T> t, Comparator comp) { Iterator small = t. begin(); Iterator current; for(current = t. begin(); current != t. end(); ++current) if(value of current < value of small) small = current; return value of small; 28 }

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 comparator 1(const T x, const T y) { if(x. a == y. a) return 0; if(x. a < y. a) return -1; return 1; } int comparator 2(const T x, const T y) { if(x. a == y. a) if(x. b = y. b) return 0; else if(x. b < y. b) return -1; else return 1; if(x. a < y. a) return -1; return 1; } September 12 int main() { printf("original sequencen"); show(x, S); selection(x, x+S, comparator 1); printf("sequence after first sortn"); show(x, S); selection(x, x+S, comparator 2); printf("sequence after second sortn"); show(x, S); } 29

template <typename Iterator, typename Predicate> void selection(Iterator first, Iterator last, Predicate compare) { Iterator eop; for(eop = first; eop != last; ++eop) swap(*min_element(eop, last, compare), *eop); } C++ implementation September 12 void selection(Seq<T> t, Comparator comp) { Seq<T>: : Iterator eop; // end of prefix for(eop = t. begin(); eop != t. end(); ++eop) swap(smallest(eop, t. end(), comp), eop); } T smallest(Seq<T> t, Comparator comp) { Iterator small = t. begin(); Iterator current; for(current = t. begin(); current != t. end(); ++current) if(value of current < value of small) small = current; return value of small; 30 }

public static void selection(List a. List, Comparator a. Comparator) { for (int i = 0; i < a. List. size(); i++) swap(smallest(i, a. List, a. Comparator) , i, a. List); } private static int smallest(int from, List a. List, Comparator a. Comp) { int min. Pos = from; int count = from; for (List. Iterator i = a. List. list. Iterator(from); i. has. Next(); ++count) if (a. Comp. compare(i. next(), a. List. get(min. Pos)) < 0) min. Pos = count; return min. Pos; void selection(Seq<T> t, Comparator comp) { Seq<T>: : Iterator eop; // end of prefix } for(eop = t. begin(); eop != t. end(); ++eop) swap(smallest(eop, t. end(), comp), eop); Java implementation September 12 } T smallest(Seq<T> t, Comparator comp) { Iterator small = t. begin(); Iterator current; for(current = t. begin(); current != t. end(); ++current) if(value of current < value of small) small = current; return value of small; 31 }

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 September 12 32

Post Test 1. What is the number of comparisons and swaps performed when selection sort is executed for: 1. sorted sequence 2. sequence sorted in reverse 2. What is the time complexity of the function is. Sorted(t), which checks if t is a sorted sequence? 3. Hand-execute the algorithm for a sample set of input data of size 4. 4. Hand-execute the next step of the algorithm for the specified state 5. What’s the last step of the algorithm? 6. There are two invariants of this algorithm; which one is essential for the correctness of swap(smallest(), eop), and why. 7. “do it yourself “ September 12 33

Quick Sort Pseudocode void quick(Seq<T> t, Comparator comp) { if( size(t) <= 1) return; pivot = choose. Pivot(t); divide(pivot, t, t 1, t 2, t 3, comp); quick(t 1, comp); quick(t 3, comp); concatenate(t, t 1, t 2, t 3); } September 12 34

September 12 35

September 12 36

September 12 37

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