MatrixPro Overview
MatrixPro is a powerful tool for illustrating algorithms in action. It has a library of predefined algorithms and data structures, but it makes it easy for users to visualize and animate their own algorithms as well. The system is implemented in Java programming language.
The tool is targeted to instructors to create algorithm animations used in teaching. It offers functionality to manipulate the automatically generated algorithm animations in order to produce the kinds of animations the lecturer wants. The animations can be prepared prior to the lecture or on-the-fly during the lectures. Teachers can also export SVG animations and Texdraw pictures to use, for example, in (electronic) books or lecture notes.
For computer science students, MatrixPro can be a tool for figuring out how different algorithms work. It also has several exercises that the student can solve to test his or her knowledge about a topic.
Features
A lecturer can create animations prior to the lecture or prepare them on-the-fly in order to demonstrate the different kinds of algorithms and data structures at hand. In addition, the instructor can ask what-if type of questions in lecture situation, and thus make the lecture more interactive. The following features aid these tasks.
Creating Animations. The Matrix framework offers an easy way to create algorithm animation by either using the automatic animation of Conceptual Data Types or by simulating the algorithm by hand. All the ready-made library structure can be animated on-the-fly by invoking operations on them. Moreover, the user can freely modify the data structure (e.g., change the binary search tree nodes and references) by hand.
Fine Tuning Animations. Although the automatically created animations are good visualizations of what the algorithm does, teachers might want to customize them. This can be done with the following operations:
- Promote an operation in the operational hierarchy (Insert Break Point to the animation)
- Demote an operation in the operational hierarchy (Remove Break Point from the animation)
- Join steps in the animation as one single step
- Disjoin one single steps in the animation to many steps
User-Made Operations. MatrixPro aids the algorithm simulation process by making it easy to invoke operations for structures from the toolbar. One can enable buttons of his own by implementing the interface matrix.structures.simulationextensions.CallableMethods. The buttons will then be automatically added in to the Contextual Panel.
For example, currently MatrixPro has implementations of AVL tree and Red-Black tree in which the automatic balancing after insertion can be turned off and the rotations/color changes can be simulated by push buttons. These buttons invoke the corresponding rotate left/right and toggle color methods in the structures.
Automatic labeling of nodes. The nodes in a structure can be automatically labeled, i.e. an unique number appears beside each node. With this feature turned on the teacher and students all know what node in the structure teacher/student refers to while explaining or asking something. In the future this kind of labeling should be also made possible for references.
Customizable user-interface
The toolbar settings can be easily modified. Thus, the user-interface can be easily customized to fit the needs of various users. Moreover, some of the properties can be customized by modifying the configuration file (matrixconf.xml by default).
Toolbar. The user can customize the toolbar to fit his/her needs very easily through a graphical dialog. Components can be moved up or down in the toolbar or they can be removed from or added to the toolbar. New components can also be added.
Configuration. By modifying the configuration file it is easy to change the contents of the menubar and pop-up menu as well as the default values used (for example font, font size and background color). In addition, the default visualizations for different structures can be changed and new visualizations added.
For more details see the configuration manual.
Algorithms and visualizations
Currently the existing data structures are:
- Table (visualized as array)
- Linked List (linked list)
- Dynamic Binary Tree (tree, graph, array)
- Static Binary Tree (8) (tree, graph, array)
- Common Tree (tree, graph, array)
- Directed Graph (graph, array)
- Undirected Graph (graph, array)
- Binary Search Tree (tree, graph, array)
- 2-3-4 Tree (tree, graph, array)
- Red-Black Tree (tree, graph, array)
- Digital Search Tree (tree, graph, array)
- Radix Search Tree (tree, graph, array)
- Binary Heap (tree, graph, array)
- AVL Tree (tree, graph, array)
- Splay Tree (tree, graph, array)
- Stack (array, linked list)
- Queue (linked list)