### The actual scheduler: `Scheduler.oz`

Source File

>     functor

>     import

>        Open

>        FD

>        OS

>        Search

>        Compiler

>        Inspector(inspect: Inspect)

>        Graphics(drawSchedule: DrawSchedule)

>        Controller(topWindow: TopWindow)
>        Latex(laTeX: LaTeX)
>        Main(controllerLabel: ControllerLabel)

>        Common(editor:          Editor
>               monday:          Monday
>               tuesday:         Tuesday
>               wednesday:       Wednesday
>               thursday:        Thursday
>               friday:          Friday
>               quartersPerDay:  QuartersPerDay
>               quartersPerHour: QuartersPerHour)

>     export

>        TimeTable

>     define

>        HourLimit           = 180
>        LecturesStartForDay = 8
>        MaximumRooms        = 7
>        Teacher1Off         = 3

>        Week = [Monday Tuesday Wednesday Thursday Friday]

>        MorningQuarters = 18

>        [MondayM TuesdayM WednesdayM ThursdayM FridayM]
>        = {Map Week fun {$ S#_} S#(S + MorningQuarters - 1) end}

>        Afternoon
>        [MondayA TuesdayA WednesdayA ThursdayA FridayA]
>        = Afternoon
>        = {Map Week fun {$ S#E} (S + MorningQuarters)#E end}

>        fun {DayTimeToQuarters Day FH FQ TH TQ}
>           Left Right Offset in
>           Offset = (36 * (Day.1 div QuartersPerDay) + 1)
>           Left  = Offset + (FH - LecturesStartForDay) * QuartersPerHour + FQ - 1
>           Right = Offset + (TH-LecturesStartForDay) * QuartersPerHour + TQ - 1
>           Left#Right
>        end

>        AstaTime = {DayTimeToQuarters Tuesday 12 3 13 3}

>        %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
>        %% Lecture and Professor Manipulation :-} Functions
>        %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

>        local

>           DayMap= map(monday:    Monday
>                       tuesday:   Tuesday
>                       wednesday: Wednesday
>                       thursday:  Thursday
>                       friday:    Friday)

>           %% Translate the constraint description
>           %% into a domain that can stand after /* :: and \:: */
>           fun {MakeC Desc}
>              case Desc
>              of inDays(L) then {Map L fun {$ D} DayMap.D end}
>              [] weekInterval(SH#SM#EH#EM) then
>                 {Map Week
>                  fun {$ Day}
>                     {DayTimeToQuarters Day SH SM div 15 EH EM div 15}
>                  end}
>              [] dayInterval(Day#SH#SM#EH#EM) then
>                 [{DayTimeToQuarters DayMap.Day SH (SM div 15) EH (EM div 15)}]
>              [] fix(Day#H#M) then
>                 [{DayTimeToQuarters DayMap.Day H (M div 15) H (M div 15)}]
>              else {Record.foldR Desc
>                    fun {$ D In} {Append {MakeC D} In} end nil}
>              end
>           end

>           %% compute the constraint procedure
>           %% for a lecturer from his/her constraint description
>           proc {ApplyConstraint Desc X}
>              case {Label Desc}
>              of noT  then  X :: compl({MakeC Desc.1})
>              [] nil         then  skip
>              else          X :: {MakeC Desc}
>              end
>           end

>           %% compute the lectures of a prof
>           %% from the lecture list
>           fun {ProfToLectures PName Ls}
>              {Filter Ls fun {$ L} L.professor==PName end}
>           end

>        in

>           fun {MakeLectures LecturesDescs Semester Ordering}
>              {Map {Record.toList LecturesDescs.Semester}
>               fun {$ Ls}
>                  {Map Ls
>                   fun {$ L}
>                      Start = {FD.int 1#(HourLimit-L.dur)}
>                   in
>                      if {HasFeature L constraints}
>                      then {ApplyConstraint L.constraints Start}
>                      else skip
>                      end
>                      {Adjoin L l(start:    Start
>                                  ordering: Ordering
>                                  semester: Semester)}
>                   end}
>               end}
>           end

>           %% translate the prof record into a
>           %% list of records, containing constraint procedures
>           fun {MakeProfessors ProfDesc Ls}
>              {Record.foldRInd ProfDesc
>               fun {$ I X In}
>                  PLs={ProfToLectures I Ls}
>               in
>                  {ForAll PLs proc {$ PL} {ApplyConstraint X PL.start} end}
>                  professor(lectures:PLs name:I) | In
>               end
>               nil}
>           end
>        end

>        %% get Lectures with size out of a given list of Specifiers
>        fun {FilterSize Specifiers Lectures}
>           {Filter Lectures fun {$ X} {Member X.size Specifiers} end}
>        end

>        %% make record for all lectures for easy access
>        fun {MakeLectureRecord Flats}
>           {List.toRecord lectures {Map Flats fun {$ L} L.name#L end}}
>        end

>        %% search for professor in list of profs
>        fun {SearchProf Profs Name}
>           {List.dropWhile Profs fun {$ P} P.name \= Name end}.1
>        end

>        %% %%%%%%%%%%%
>        %% Enumeration
>        %% %%%%%%%%%%%

>        local
>           fun {SkipWait Xs}
>              case Xs
>              of X|Xr then case {FD.reflect.size X.start}
>                           of 1 then {SkipWait Xr}
>                           else Xs
>                           end
>              [] nil then nil
>              end
>           end

>           proc {Choose Xs HoleTail HoleHead MinYet SizeYet ?Min ?Ys}
>              case Xs
>              of X|Xr then
>                 SizeX = {FD.reflect.size X.start} in
>                 case SizeX of 1 then
>                    {Choose Xr HoleTail HoleHead MinYet SizeYet Min Ys}
>                 elseif SizeX < SizeYet then
>                    NewHole in
>                    HoleTail = MinYet | HoleHead
>                    {Choose Xr Ys NewHole X SizeX Min NewHole}
>                 else
>                    Ys=X | {Choose Xr HoleTail HoleHead MinYet SizeYet Min}
>                 end
>              [] nil then Min = MinYet Ys = nil HoleTail = HoleHead
>              end
>           end
>           fun {Cost I Ls C}
>              case Ls of nil then
>                 {Exception.raiseError college(Cost [I Ls C] 'tragic error')}
>                 _
>              [] A#B|Lr then
>                 if A =< I andthen I =< B
>                 then C
>                 else {Cost I Lr C+1}
>                 end
>              end
>           end

>           fun {GetFirst Domain Min MinVal Ordering}
>              case Domain of nil then Min
>              [] D|Dr
>              then TMinVal = {Cost D Ordering 1} in
>                 if TMinVal<MinVal then {GetFirst Dr D TMinVal Ordering}
>                 else {GetFirst Dr Min MinVal Ordering}
>                 end
>              end
>           end
>        in
>           proc {Enum Xs}
>              choice
>                 case {SkipWait Xs}
>                 of nil then skip
>                 [] X|Xr then
>                    Y Yr Hole Val YDom YVar in
>                    {Choose Xr Yr Hole X {FD.reflect.size X.start} Y Hole}
>                    {Wait Y}
>                    YVar = Y.start
>                    YDom = {FD.reflect.domList YVar}
>                    Val = {GetFirst YDom.2 YDom.1 {Cost YDom.1 Y.ordering 1}
>                           Y.ordering}
>                    choice
>                       YVar=Val {Enum Yr}
>                    []
>                       YVar\=:Val {Enum Y|Yr}
>                    end
>                 end
>              end
>           end
>        end

>        %% %%%%%%%%%%%%%%%%%%%%%
>        %% Branch and Bound Cost Function
>        %% %%%%%%%%%%%%%%%%%%%%%
>        local
>           fun {SumUp Lectures Time}
>              case Lectures of nil then nil
>              [] L|Lr
>              then case {Atom.toString L.name}.1
>                   of &M then 0|{SumUp Lr Time}
>                   [] &F then 0|{SumUp Lr Time}
>                   else (L.start::Time)|{SumUp Lr Time}
>                   end
>              end
>           end
>        in
>           fun {Cost Lectures}
>              Costs = {FD.decl} in
>              {FD.sum {SumUp Lectures [MondayA TuesdayA WednesdayA ThursdayA FridayA]} '=:' Costs}
>              Costs
>           end
>        end

>        %% %%%%%%%%%%%%%%%%%%%%%
>        %% Constraint Procedures
>        %% %%%%%%%%%%%%%%%%%%%%%

>        proc {OnSpecialDayOnly Lectures Day}
>           {ForAll Lectures proc {$ Lec} Lec.start :: Day end}
>        end
>        proc {OnSpecialTimeOnly Lectures Time}
>           {ForAll Lectures proc {$ Lec} Lec.start :: Time end}
>        end
>        proc {ForbidAsta Lectures}
>           {ForAll Lectures
>            proc {$ Lec} Lec.start :: compl((AstaTime.1-Lec.dur+1)#AstaTime.2) end}
>        end
>        proc {DayBreak Break Lectures}
>           {ForAll Lectures
>            proc {$ Lec}
>               {ForAll Break proc{$ B}
>                                Left = (B.1-Lec.dur)
>                             in
>                                if Left < 0 then
>                                   Lec.start :: compl(0#B.2)
>                                else
>                                   Lec.start :: compl(Left#B.2)
>                                end
>                             end}
>            end}
>        end

>        proc {NotParallel Offset Teacher1 Teacher15}
>           {ForAll Teacher1.lectures
>            proc {$ FL}
>               {ForAll Teacher15.lectures
>                proc{$ LFL}
>                   {FD.disjoint FL.start FL.dur+Offset LFL.start LFL.dur+Offset}
>                end}
>            end}
>        end

>        %% The lectures of a semester must not overlap

>        proc {NoOverlapSemester Lectures}
>           case Lectures of nil then skip
>           [] L|Lr
>           then {NoOverlap1 Lr L} {NoOverlapSemester Lr}
>           end
>        end
>        proc {NoOverlap1 Lecs Lec1}
>           case Lecs of nil then skip
>           [] L|Lr
>           then {NoOverlap2 Lec1 L} {NoOverlap1 Lr Lec1}
>           end
>        end
>        proc {NoOverlap2 L1 L2}
>           {ForAll L1
>            proc{$ L}
>               {ForAll L2
>                proc {$ LP}
>                   %% After one hour must be a quarter
>                   %% and after two hours two quarters
>                   %% recreation time
>                   LDur LPDur in
>                   LDur= if L.dur<4
>                         then L.dur+1
>                         else L.dur+2
>                         end
>                   LPDur= if LP.dur<4
>                          then LP.dur+1
>                          else LP.dur+2
>                          end
>                   {FD.disjoint L.start LDur LP.start LPDur}
>                end}
>            end}
>        end

>        %% The lectures of a professor must not overlap
>        proc {NoOverlapLectures Lectures}
>           case Lectures of nil then skip
>           [] L|Lr
>           then {NoOverlapLecs1 L Lr} {NoOverlapLectures Lr}
>           end
>        end

>        proc {NoOverlapLecs1 Lec Lec1}
>           case Lec1 of nil then skip
>           [] L|Lr
>           then {NoOverlapLecs2 Lec L} {NoOverlapLecs1 Lec Lr}
>           end
>        end

>        proc {NoOverlapLecs2 L1 L2}
>           %% After one hour must be a quarter
>           %% and after two hours two quarters
>           %% recreation time
>           L1Dur L2Dur in
>           L1Dur= if L1.dur < 4 then L1.dur + 1 else L1.dur + 2 end
>           L2Dur= if L2.dur < 4 then L2.dur + 1 else L2.dur + 2
>                  end
>           {FD.disjoint L1.start L1Dur L2.start L2Dur}
>        end

>        %% Constraint AtMostLectures for rooms

>        local
>           fun {SumUpLectures Lectures Hour}
>              case Lectures
>              of L|Lr
>              then
>                 %% Rooms are empty for a quarter after each lecture
>                 Left = Hour-(L.dur+1)+1
>              in
>                 if Left < 0 then (L.start :: 0#Hour)|{SumUpLectures Lr Hour}
>                 else             (L.start :: Left#Hour)|{SumUpLectures Lr Hour}
>                 end
>              [] nil then nil
>              end
>           end
>        in
>           proc {AtMostLectures Lectures Limit}
>              {For 1 HourLimit 1
>               proc{$ Hour}
>                  {FD.sum {SumUpLectures Lectures Hour} '=<:' Limit}
>               end}
>           end
>        end

>        %% Constraint ThreeDaysOnly and OnDifferentDays

>        local
>           fun {SumUp Lectures Day}
>              case Lectures of nil then nil
>              [] L|Lr
>              then (L.start :: Day)|{SumUp Lr Day}
>              end
>           end
>           proc {SumUpDays Lectures BDay Day}
>              S= {SumUp Lectures Day}
>           in
>              BDay = ({FoldL S FD.plus 0} >=: 1)
>           end
>        in
>           proc {ThreeDaysOnly Lectures DayLimit}
>              [BMo BTu BWe BTh BFr]={FD.dom 0#1}
>           in
>              BMo+BTu+BWe+BTh+BFr =<: DayLimit
>              {SumUpDays Lectures BMo Monday}
>              {SumUpDays Lectures BTu Tuesday}
>              {SumUpDays Lectures BWe Wednesday}
>              {SumUpDays Lectures BTh Thursday}
>              {SumUpDays Lectures BFr Friday}
>           end
>           proc {OnDifferentDays Lectures}
>              [BMo BTu BWe BTh BFr]={FD.dom 0#1}
>           in
>              BMo+BTu+BWe+BTh+BFr =: {Length Lectures}
>              {SumUpDays Lectures BMo Monday}
>              {SumUpDays Lectures BTu Tuesday}
>              {SumUpDays Lectures BWe Wednesday}
>              {SumUpDays Lectures BTh Thursday}
>              {SumUpDays Lectures BFr Friday}
>           end
>           proc {OnSameDay Lectures}
>              [BMo BTu BWe BTh BFr]={FD.dom 0#1}
>           in
>              BMo+BTu+BWe+BTh+BFr =: 1
>              {SumUpDays Lectures BMo Monday}
>              {SumUpDays Lectures BTu Tuesday}
>              {SumUpDays Lectures BWe Wednesday}
>              {SumUpDays Lectures BTh Thursday}
>              {SumUpDays Lectures BFr Friday}
>           end
>        end
>        local
>           fun {SumUpOverlaps L1 Lectures}
>              case Lectures of nil then nil
>              [] L2|Lr then B={FD.int 0#1} L1Dur L2Dur in
>                 if L1.name==L2.name then 0|{SumUpOverlaps L1 Lr}
>                 else L1S L2S in
>                    L1Dur= if L1.dur < 4 then L1.dur + 1 else L1.dur + 2 end
>                    L2Dur= if L2.dur < 4 then L2.dur + 1 else L2.dur + 2 end
>                    L1S = L1.start
>                    L2S = L2.start

>                    /* That is the (operational) semantics of FD.tasksOverlap.
>                       FD.tasksOverlap implements constructive disjunction.
>                    condis
>                       B=:1
>                       L1S + L1Dur >: L2S
>                       L2S + L2Dur >: L1S
>                    []
>                       B=:0
>                       L1S + L1Dur =<: L2S
>                    []
>                       B=:0
>                       L2S + L2Dur =<: L1S
>                    end
>                    */
>                    {FD.tasksOverlap L1S L1Dur L2S L2Dur B}
>                    B|{SumUpOverlaps L1 Lr}
>                 end
>              end
>           end
>        in
>           proc {AtmostOneOverlap Lecture Lectures}
>              {FD.sum {SumUpOverlaps Lecture Lectures} '=<:' 1}
>           end
>        end

>        %% %%%%%%%%%%%
>        %% The Problem
>        %% %%%%%%%%%%%

>        %% MakeProblem makes the problem procedure
>        %% using the problem description as global variable

>        fun {MakeProblem ProblemDescription}

>           proc {$ FlatAllLectures}

>              %% %%%%%%%%
>              %% Lectures
>              %% %%%%%%%%

>              LecturesDescription = ProblemDescription.lectures

>              %% Second Semester
>              %% %%%%%%%%%%%%%%%

>              LecturesSecond = {MakeLectures
>                                LecturesDescription
>                                second
>                                %% other priorities

>                                [MondayM MondayA
>                                 TuesdayA TuesdayM
>                                 WednesdayM WednesdayA
>                                 FridayM  FridayA
>                                 ThursdayM ThursdayA
>                                ]
>                               }
>              %% Fourth Semester
>              %% %%%%%%%%%%%%%%%

>              LecturesFourth = {MakeLectures
>                                LecturesDescription
>                                fourth
>                                %% other priorities

>                                [
>                                 WednesdayM WednesdayA
>                                 TuesdayM TuesdayA
>                                 MondayM MondayA
>                                 ThursdayM ThursdayA
>                                 FridayM FridayA
>                                ]

>                               }
>              GrundStudiumLectures = {Append LecturesSecond LecturesFourth}
>              FlatGrundStudiumLectures = {List.flatten GrundStudiumLectures}

>              %% Sixth Semester
>              %% %%%%%%%%%%%%%%

>              LecturesSixth = {MakeLectures
>                               LecturesDescription
>                               sixth
>                               %% other priorities

>                               [ WednesdayM WednesdayA
>                                 FridayM FridayA
>                                 ThursdayM ThursdayA
>                                 MondayM MondayA
>                                 TuesdayM TuesdayA
>                               ]
>                              }

>              FlatLecturesSixth = {List.flatten LecturesSixth}

>              %% Eighth Semester
>              %% %%%%%%%%%%%%%%%

>              LecturesEighth = {MakeLectures
>                                LecturesDescription
>                                eighth
>                                [
>                                 ThursdayM ThursdayA
>                                 WednesdayA WednesdayM
>                                 MondayA  MondayM
>                                 TuesdayA TuesdayM
>                                 FridayM FridayA
>                                ]}

>              FlatLecturesEighth = {List.flatten LecturesEighth}

>              NotOnThursdayLectures = {Append GrundStudiumLectures LecturesSixth}
>              AllSemesterLectures = {Append NotOnThursdayLectures LecturesEighth}
>              FlatAllSemesterLectures={List.flatten AllSemesterLectures}

>              %% Medien Lectures
>              %% %%%%%%%%%%%%%%%

>              MedienLectures = {MakeLectures
>                                LecturesDescription
>                                medien
>                                [
>                                 ThursdayA TuesdayA
>                                 TuesdayM ThursdayM
>                                 WednesdayM WednesdayA
>                                 MondayM MondayA
>                                 FridayM FridayA
>                                ]}

>              FlatMedienLectures = {List.flatten MedienLectures}

>              %% Fakult Lectures
>              %% %%%%%%%%%%%%%%%

>              FakLectures = {MakeLectures
>                             LecturesDescription
>                             fac
>                             [
>                              WednesdayM WednesdayA
>                              ThursdayM ThursdayA
>                              MondayM MondayA
>                              FridayM FridayA
>                              TuesdayM TuesdayA
>                             ]
>                            }

>              FlatFakLectures = {List.flatten FakLectures}

>              AllLectures = {Append AllSemesterLectures
>                             {Append MedienLectures FakLectures}}

>              !FlatAllLectures = {List.flatten AllLectures}

>              L = {MakeLectureRecord FlatAllLectures}

>              %% %%%%%%%%%%
>              %% Professors
>              %% %%%%%%%%%%

>              ProfessorsDescription = ProblemDescription.professors

>              Professors = {MakeProfessors ProfessorsDescription FlatAllLectures}

>           in

>              %% %%%%%%%%%%%%%%%
>              %% The Constraints
>              %% %%%%%%%%%%%%%%%

>              %% General constraints
>              %% Lecture must be finished at 17.00

>              {ForAll FlatAllLectures
>               proc{$ L}
>                  Dur = L.dur
>                  fun {AfterHours Day} Day.2 + 1 - Dur#Day.2  end
>               in
>                  L.start :: compl({Map Week AfterHours})
>               end}

>              %% All semesters but the eighth are not scheduled on thursday
>              %% seems to be to hard

>              {OnSpecialDayOnly FlatLecturesSixth Wednesday}
>              %% The break must be lecturefree

>              {DayBreak
>               {List.map [0 1 2 3 4] fun{$ I} (20+I*36)#(23+I*36) end}
>               {Append FlatLecturesEighth FlatGrundStudiumLectures}}

>              {DayBreak {List.map [0 1 2 3 4]
>                         fun{$ I} (16+I*36)#(19+I*36) end}
>               FlatLecturesSixth}

>              %% At Asta time no lectures allowed
>              {ForbidAsta FlatAllLectures}

>              %% The Lectures for a semester must not overlap
>              {NoOverlapSemester [[L.'2.1' L.'2.2' L.'2.3']
>                                  [L.'2.6']
>                                  [L.'2.7']
>                                  [ L.'2.9']
>                                  [L.'2.10.1' L.'2.10.2' L.'2.10.3']
>                                  [L.'2.5.1' L.'2.5.2' L.'2.8.1' L.'2.8.2'
>                                   L.'2.13.1' L.'2.13.2' L.'2.4.1' L.'2.4.2'
>                                   L.'2.14.1' L.'2.14.2' L.'2.15.1' L.'2.15.2'
>                                   L.'2.15.3' L.'2.15.4' ]]}

>              {ForAll [L.'2.5.1' L.'2.5.2' L.'2.8.1' L.'2.8.2'
>                       L.'2.13.1' L.'2.13.2' L.'2.4.1' L.'2.4.2'
>                       L.'2.14.1' L.'2.14.2']
>               proc{$ Lecture}
>                  {AtmostOneOverlap Lecture [L.'2.5.1' L.'2.5.2' L.'2.8.1'
>                                             L.'2.8.2' L.'2.13.1' L.'2.13.2'
>                                             L.'2.4.1' L.'2.4.2' L.'2.14.1'
>                                             L.'2.14.2' L.'2.15.1' L.'2.15.2'
>                                             L.'2.15.3' L.'2.15.4']}
>               end}
>              {ForAll [L.'2.15.1' L.'2.15.2' L.'2.15.3' L.'2.15.4']
>               proc{$ Lecture}
>                  {AtmostOneOverlap Lecture [L.'2.5.1' L.'2.5.2' L.'2.8.1'
>                                             L.'2.8.2' L.'2.13.1' L.'2.13.2'
>                                             L.'2.4.1' L.'2.4.2' L.'2.14.1'
>                                             L.'2.14.2']}
>               end}

>              {NoOverlapSemester [[L.'4.1'] [L.'4.6'] [L.'4.11' ]
>                                  [ L.'4.2.1' L.'4.2.2' L.'4.3.1' L.'4.3.2'
>                                    L.'4.4.1' L.'4.4.2' L.'4.5.1' L.'4.5.2'
>                                    L.'4.7.1' L.'4.7.2' L.'4.10.1' L.'4.10.2'
>                                    L.'4.12.1' L.'4.12.2'
>                                    L.'4.8.1' L.'4.8.2' L.'4.8.3' L.'4.8.4']]}

>              {ForAll [ L.'4.2.1' L.'4.2.2' L.'4.3.1' L.'4.3.2'
>                        L.'4.4.1' L.'4.4.2' L.'4.5.1' L.'4.5.2'
>                        L.'4.7.1' L.'4.7.2' L.'4.10.1' L.'4.10.2'
>                        L.'4.12.1' L.'4.12.2']
>               proc{$ Lecture}
>                  {AtmostOneOverlap
>                   Lecture [ L.'4.2.1' L.'4.2.2' L.'4.3.1' L.'4.3.2'
>                             L.'4.4.1' L.'4.4.2' L.'4.5.1' L.'4.5.2'
>                             L.'4.7.1' L.'4.7.2' L.'4.10.1' L.'4.10.2'
>                             L.'4.12.1' L.'4.12.2'
>                             L.'4.8.1' L.'4.8.2' L.'4.8.3' L.'4.8.4']}
>               end}

>              {ForAll [L.'4.8.1' L.'4.8.2' L.'4.8.3' L.'4.8.4']
>               proc{$ Lecture}
>                  {AtmostOneOverlap
>                   Lecture [ L.'4.2.1' L.'4.2.2' L.'4.3.1' L.'4.3.2'
>                             L.'4.4.1' L.'4.4.2' L.'4.5.1' L.'4.5.2'
>                             L.'4.7.1' L.'4.7.2' L.'4.10.1' L.'4.10.2'
>                             L.'4.12.1' L.'4.12.2' ]}
>               end}

>              {NoOverlapSemester [[L.'6.2.1' L.'6.2.2'] [L.'6.5' L.'6.6'] ]}
>              {NoOverlapSemester [[L.'8.1'][L.'8.2'][L.'8.3'][L.'8.4']
>                                  [L.'8.5'][L.'8.6'][L.'8.7.2'][L.'8.8']
>                                  [L.'8.9'][L.'8.10']
>                                 ]}

>              %% Lectures for a professor must not overlap
>              {ForAll Professors proc{$ L} {NoOverlapLectures L.lectures} end}

>              %% At most MaximumRooms concurrent
>              {AtMostLectures {FilterSize [big small tiny] FlatAllLectures}
>               MaximumRooms}

>              %% Aula and 155 lectures at most 2
>              {AtMostLectures {FilterSize [big] FlatAllLectures} 2}

>              %% Rooms Aula, 155, 152, 154, 250 lectures at most 5
>              {AtMostLectures {FilterSize [big small] FlatAllLectures} 5}

>              %% All professors have a teaching limit of 3 days per week
>              {ForAll Professors
>               proc{$ Professor} {ThreeDaysOnly Professor.lectures 3} end}

>              %% At most 6 hours per day
>              {ForAll Professors
>               proc{$ Professor}
>                  {ForAll [Monday Tuesday Wednesday Thursday Friday]
>                   proc{$ Day}
>                      {FoldL Professor.lectures
>                       fun{$ I L}
>                          {FD.plus {FD.times L.dur (L.start::Day)} I}
>                       end 0} =<: 6*4
>                   end}
>               end}

>              %% Teacher1/Teacher15 couple cannot teach at the same time (+offset)
>              {NotParallel
>               Teacher1Off
>               {SearchProf Professors 'Teacher1'}
>               {SearchProf Professors 'Teacher15'}}

>              %% Special constraints for 2nd semester
>              L.'2.1'.start=L.'2.2'.start=L.'2.3'.start
>              L.'2.10.1'.start=L.'2.10.2'.start=L.'2.10.3'.start
>              L.'2.15.1'.start=L.'2.15.2'.start=L.'2.15.3'.start=L.'2.15.4'.start

>              %% Special constraints for 4th semester
>              {OnDifferentDays [L.'4.7.1' L.'4.7.2']}  % Teacher17's lecture

>              %% Special constraints for 6th semester
>              L.'6.5'.start=L.'6.6'.start
>              (L.'6.5'.start) >: {FD.max L.'6.2.1'.start L.'6.2.2'.start}

>              L.'6.2.1'.start=L.'6.2.2'.start=L.'6.2.3'.start

>              %% Special constraints for eighth semester

>              %% Special constraints for Mediendidaktik
>              {NoOverlapSemester [FlatGrundStudiumLectures FlatMedienLectures]}

>              %% Special constraints for Fakultative Veranstaltungen
>              {NoOverlapSemester FakLectures}
>              {OnSpecialTimeOnly FlatFakLectures Afternoon}

>              %% Special constraint for Teacher32
>              {OnSameDay [L.'F.2.1' L.'F.2.2']}

>              %% %%%%%%%%%%%%%%%
>              %% The Enumeration
>              %% %%%%%%%%%%%%%%%

>              {Enum FlatAllSemesterLectures}
>              {Enum {Append FlatMedienLectures FlatFakLectures}}
>           end
>        end

>        class TimeTableClass from BaseObject
>           attr
>              problemDescription: nil
>              solution
>              dir
>              first: true
>              solver

>           meth readProblem(InputFileName)
>              if InputFileName==false then skip
>              else
>                 InputFile = {New Open.file init(name:InputFileName
>                                                 flags: [read])}
>                 Read = {InputFile read(size:all list:$)}
>              in
>                 problemDescription <- {Compiler.virtualStringToValue Read}
>              end
>           end

>           meth setDir(D)
>              dir <- D
>           end

>           meth getDir(?D)
>              D = @dir
>           end

>           meth setProblem(P)
>              problemDescription <- P
>           end

>           meth inspectProblem
>              {Inspect @problemDescription}
>           end

>           meth constrainProblem
>              solution <- {{MakeProblem @problemDescription}}
>           end

>           meth solveProblem
>              PD = @problemDescription
>           in
>              first <- true
>              if PD == nil then
>                 {ControllerLabel tk(configure text:'No problem loaded')}
>              else
>                 solver <- {New Search.object
>                            script({MakeProblem PD}
>                                   proc{$ Old New}
>                                      CN = {Cost New}
>                                      CO = {Cost Old} in
>                                      CN <: CO
>                                      thread
>                                         {Wait CO}
>                                         /*{Show {FD.reflect.min CO}}*/
>                                      end
>                                   end
>                                   rcd : 20)}
>                 local Solver = @solver in
>                    {self setSolution(thread {Solver next($)} end)}
>                 end
>              end
>           end
>           meth optimizeProblem
>              Solver = @solver in
>              {ControllerLabel tk(configure text:'Computing...')}
>              {self setSolution(thread {Solver next($)} end)}
>           end
>           meth setSolution(Sol)
>              thread
>                 if Sol==nil then
>                    {ControllerLabel tk(configure text:'No solution')}
>                 elseif Sol==stopped then
>                    {ControllerLabel tk(configure text:'Stopped')}
>                 else
>                    {self help(Sol)}
>                 end
>              end
>           end
>           meth help(Sol)
>              Solver = @solver in
>              solution <- Sol
>              if @first  then
>                 first <- false
>                 {self graphic}
>              else skip
>              end
>              {self setSolution(thread {Solver next($)} end)}
>           end
>           meth get(?Sol)
>              Sol=@solution
>           end
>           meth anyTime
>              {@solver stop}
>           end
>           meth inspect
>              {Inspect {Map @solution fun {$ X} {Record.subtract X ordering} end}}
>           end
>           meth text
>              {LaTeX show @solution}
>           end
>           meth print
>              {LaTeX print @solution}
>           end
>           meth graphic
>              {DrawSchedule @solution.1 TopWindow}
>           end
>           meth edit(FileName)
>              if FileName==false then skip
>              else
>                 {OS.system Editor#' '#FileName#'\&' _}
>              end
>           end
>           meth save(OutputFileName)
>              if OutputFileName==false then skip
>              else
>                 F = {New Open.file init(name:OutputFileName
>                                         flags: [read write 'create'])}
>              in
>                 {F write(vs:{Value.toVirtualString @solution 100 100})}
>              end
>           end
>     \ifndef ALONEDEMO
>           meth read(FileName)
>              if FileName==false then skip
>              else
>                 File = {New Open.file init(name:FileName
>                                            flags: [read write 'create'])}
>              in
>                 solution <- {Compiler.virtualStringToValue
>                              {File read(size:all list:$)}}
>              end
>           end
>     \else
>           meth read(_)
>              solution <-
>              \insert KathHochWS9596Sol.ozt
>           end
>     \endif
>        end

>        TimeTable = {New TimeTableClass
>     \ifdef ALONEDEMO
>                     setProblem(
>                        \insert KathHochWS9596.ozt
>                        )
>     \else
>                     noop
>     \endif
>                    }
>     end