- Artificial intelligence timetabling algorithm
- Constraints entry
- Constraints' importance
- "Violations" pane
- Ability to resume automation
- Critical constraints
- Combinations Engine
- Fixating cells
- Multiple desirable values
- Groups of students
- Subjects and sub-subjects
- Simultaneous sets
- Room capacity
- Display students by groups
- Custom order of resources
- Very large databases
- Looking up resources
- Quantities of equipment
- Assign colors to resources
- Blocked cells
- Planned quantity for activities
- Notes for cells
- Flipped axes
- Abbreviated names
- Custom columns
- Multiple optional rooms for an activity
- Assign students either to groups or to activities
- Not necessary to enter student names
- Length of activities
- Custom phrases
- Rooms' pane
- Which activity is free?
- Which cell is free?
- Where can a cell be moved to?
- Focus on the selected resource's activities
- Properties window
- Activity's timetable
- Involved resources' timetables
- Which resources are free?
- Timetable of multiple resources and days
- Resolving conflicts
- Total scheduled quantity
- Smart conflict prediction
- "Changes" mode
- View settings
- Undo and redo
- In-place editing mode
- Reports module
- Importing data
- The "Gaps" Constraint
- The "Late Starts" Constraint
- The "Consecutive Cells" Constraint
- The "Cells Per Day" Constraint
- The "Period Range" Constraint
- Combinations to Schedule an Activity
- Combinations' Coverage
- Scheduling Activities, Not Resources
- Drag and Drop Principle of Cells and Activities
- Days and Dates Selection in the Navigation Pane
- Timescales and Periods
- Length of Activities
- Custom Properties
- Making Replacement Changes
- Scheduling, Duplicating and Resizing Activities
- Conflict Stripes and Conflicts Window
Clicking on the "Solve All" button at the bottom right corner of the screen sets in motion an Artificial-Intelligence based solver which scans millions of possibilities in order to ultimately find the best timetable. It is well known that the problem of automatic timetabling is a difficult problem from the aspect of computerization and no ideal algorithm has been found so far. However, the program's unique ability to efficiently predict the best chain of moves to a successful timetable completion makes it in-effect the proof that this problem is indeed solvable.
In order to construct a suitable timetable, the program allows you to define a wide variety of constraints and the importance of each of these constraints. Each constraint has three fields: minimal value, maximal value and a desirable value. When the timetable does not satisfy the min/max values of the constraint, it is considered by the program as a more serious violation than when the desirable value is not upheld. It is very important to define only the relevant constraints for you, and not over-constrain the software in a way that a timetable cannot be feasibly constructed. It is always possible to change the constraints - even when the timetable is fully or partially constructed. The software adapts to the new/changed constraints and makes the necessary adjustments to meet them.
The program treats the process of timetable construction as the process of solving violations. A violation is when some aspect of the timetable at this moment is not as it should be in the final result. When the timetable is empty, for example, it has many violations, at least as many as the number of activities - they all should be scheduled but they are currently not. During the automation, the software tries to gradually improve the quality of the timetable by resolving these violations. Each time it finds a suitable way to decrease the number of violations in the timetable, it does so. That is why the whole automation process is essentially a process of continuous search for improvements. The software starts by allocating a small amount of time to resolving each violation. This allows it to resolve all the easy violations relatively quickly. Then it increases the allocated time per violation, and continues to solve the more difficult ones. The software repeats this technique multiple times, until either all violations are resolved or it reaches the maximal allocated time.
If the software is unable to resolve all the violations, the key word is - compromise. Assuming that all the constraints that you have entered are in fact relevant and important to you, there is no escape from relaxing some of them in order to expand the legitimate solution space. The difficult task in such circumstances is to know exactly which constraints to relax. The fact is that each and every one of the constraints may directly or indirectly affect any other constraint. So basically this becomes a process of trial and error and the best thing to do is just to follow your hunch. What we do recommend is first to go over the constraints that you have entered and leave only the absolutely crucial ones. Then let the program construct the timetable. Afterwards, add some more constraints and let the program adjust the timetable to the new constraints, and repeat this process several times. This incremental technique of constructing the timetable usually leads to the best results when dealing with the more complex timetabling scenarios.
In addition to a fully automatic way of timetable construction, the software offers a "semi-automatic" mode. The meaning of "semi-automatic" is that although the program automatically calculates complex multi-depth combinations of how you can accomplish a certain task (move some cell away, schedule a new activity or fill an empty cell) and presents you with the viable solutions that it has found, the final decision which solution to actually apply is eventually yours. The program does take care of presenting you only the possibilities which do not create any conflicts nor delete any scheduled activities. Only possibilities in which cells are moved or switched with each other are presented.
You can control the complexity of the possibilities that the program is allowed to find simply by selecting whose timetable you see on your screen. For example, if a single instructor's weekly timetable is currently shown and you wish to move some cell in that timetable, the possibilities that the program will find will involve only the cells of that instructor. In this case the program will not present options in which moving the cell conflicts with a cell of another instructor. If, however, you are viewing the weekly timetable of all the instructors on your screen, and then ask the program to find the possibilities, it will present complex rearrangement scenarios which may involve other instructors as well.
It is perfectly possible to construct the whole timetable with this Semi-Automatic combinations engine. Users who prefer to have close control over each step of the timetabling process can use the power of this tool to schedule each activity separately. You wouldn't have to actually search for a vacant spot for each activity, but rather to merely approve one of the software's found "musical-chair" rearrangements.
In order to assess the quality of some found combination, you can have the program "freeze" it on your screen. This is done simply by clicking on it in the list of combination thumbnails at the bottom of the screen. The arrows depicting the cells' movement will remain visible even when you browse to other timetables. This allows you to understand the effect of the combination on all affected resources. Eventually you can either apply the combination by double clicking on it, or cancel it by clicking on it again to deselect it.
When it comes to making manual changes in the timetable, the software provides you with two important benefits. First, it monitors your every move and makes sure to warn you about any conflict or clash (such as when you try to double-book a resource). Second, and most important, it provides you with comfort. The convenient ease with which you can accomplish many repeating tasks stems from features such as drag & drop (for scheduling new activities or moving existing ones), the properties pane (in which you can edit any property of the currently selected activity or resource), undo & redo (any action can be undone) and more.
What is also comfortable is that information about resource availability and potential conflicts is displayed to you when you need it without even having to ask for it. For example, when you start to drag an activity or a cell, the program automatically shows where you can drop it without causing a conflict, as well as where any of the involved resources is unavailable. When you are editing any cell's property in the properties pane (choosing a room for a scheduled activity for instance) you are shown the state (available or not) of each resource in the drop-down list of resources.
If you do run into a conflict in the interactive mode, the conflict will be explained in detail in the Conflicts window. If it's a matter of double booking of some resource, the Conflicts window will also allow you to delete one of the conflicting activities directly from that window by placing an "X" in the check box near that activity. If you choose to ignore a conflict (which you can do, thus allowing a resource double booking for example), you can always see it in the Conflicts pane at the right side of the workspace. This pane lists all the existing conflicts in the timetable. If you double click on any conflict's row in that list, you will be taken directly to the relevant conflicting resources' time-range in the timetable.
As a whole, the user's experience with the software is straightforward and intuitive, and the design is very visual and modern. There are no popup windows that clutter your workspace or obscure information. Both the database and the timetable are on the same screen, so you do not have to constantly go back and forth between them. Special "grouping & sorting" tabs at the top of long lists allow you to narrow down these lists to specific selection-oriented resources or activities. The main timetable view can be split to multiple views horizontally or vertically. If you have a dual-monitor setup, you can even open a separate window on each monitor so that any change you make on one monitor is immediately synchronized on the second one.
When the timetable is planned upfront for a month, a semester or a year, it's often required to make changes on a daily basis to accommodate to the everyday reality of absences, variable unplanned events, holiday activities and more. The "Changes" module takes the planned timetable as a starting point, and allows you to modify it just like you are used to in the "Planned" mode. Each cell that is different from the original planned cell is marked as such and each change is recorded. Naturally, you can always restore a change and go back to the original cell using the "Restore" button.
Whereas the planned timetable is constructed for generic days, and serves as a template for the upcoming semester's timetable, the modifications that you make in the Changes mode are applied to specific calendar dates. That's because in the "Changes" mode you switch to working with a calendar instead of a list of weekdays like in the "Planned" mode.
All the tools that you are used to working with in the Interactive mode are available in the Changes mode as well, and they take under account both the original timetable and the subsequent changes that you made "on top of it". Once you have cancelled a cell as a result of an absent instructor, for example, it is considered empty on that date, and the conflict calculation and prediction mechanisms all throughout the software are aware of this.
All the changes are summed up in the Changes pane at the right side of the workspace. Just like in the "Conflicts" pane, double clicking on any row in the "Changes" pane takes you to the relevant cell of the change. The changes are listed separately for each affected resource. The Changes pane can also be exported as a report by switching to the "Reports" module and selecting the "Changes" report. You can sort the changes according to dates, periods and resources. You can also choose to print the timetable as a grid showing only the changed cells, while blanking out the original unchanged cells.