Problem solver for computing plans: Plan.oz

### Problem solver for computing plans: `Plan.oz`

Source File

>     functor

>     import
>        Search(base)
>        FD
>        Country(getDist getDetourDist)
>        Configure(capacity: Capacity)

>     export
>        make: MakePlan

>     define

>        %%
>        %% Defaults used
>        %%

>        proc {InsertSrc JA|Js Src Dst Weight What ?C ?NJs}
>           case Js of nil then
>              if Src==JA.city then
>                 NJs = [act(city:Src
>                            load:Weight
>                            lift:What|JA.lift
>                            drop:JA.drop)
>                        act(city:Dst
>                            load:0
>                            lift:nil
>                            drop:[What])]
>                 C   = {Country.getDist Src Dst}
>              else
>                 NJs = [JA
>                        act(city: Src
>                            load: Weight
>                            lift: [What]
>                            drop: nil)
>                        act(city: Dst
>                            load: 0
>                            lift: nil
>                            drop: [What])]
>                 C   = ({Country.getDist JA.city Src}
>                        + {Country.getDist Src Dst})
>              end
>           [] JB|_ then
>              NewLoad = JA.load + Weight
>           in
>              if NewLoad>Capacity then
>                 %% Job cannot placed here, because load would exceed the
>                 %% capacity of the truck
>                 NJs=JA|{InsertSrc Js Src Dst Weight What ?C}
>              else
>                 dis NewJob in
>                    if Src==JA.city then
>                       %% Okay, the truck drives to this city anyway, so
>                       %% simply add this good
>                       NJs = (act(city: Src
>                                  load: NewLoad
>                                  lift: What|JA.lift
>                                  drop: JA.drop) = NewJob)
>                           | {InsertDst NewJob Js Dst Weight What ?C}
>                    else TmpTour={FD.int 0#FD.sup} in
>                       %% Add the city to the towns the truck has to visit
>                       NJs = (JA
>                              | (act(city: Src
>                                     load: NewLoad
>                                     lift: [What]
>                                     drop: nil) = NewJob)
>                              | {InsertDst NewJob Js Dst Weight What ?TmpTour})
>                       C =: TmpTour
>                            + {Country.getDetourDist JA.city Src JB.city}
>                    end
>                 [] % ...or somewhere else
>                    NJs=JA|{InsertSrc Js Src Dst Weight What ?C}
>                 end
>              end
>           end
>        end

>        proc {InsertDst JA Js Dst Weight What ?C ?NJs}
>           %% JA is loaded with Order. Order.to has to be placed
>           %% after JA either between planned cities or on planned
>           %% cities. Recursion tries to keep Order transported up to
>           %% cities later in Plan
>           case Js of nil then
>              C   = {Country.getDist JA.city Dst}
>              NJs = [act(city: Dst
>                         load: 0
>                         lift: nil
>                         drop: [What])]
>           [] JB|Jr then
>              dis
>                 if JB.city==Dst then
>                    C   = 0
>                    NJs = {AdjoinAt JB drop What|JB.drop} | Jr
>                 else
>                    C   = {Country.getDetourDist JA.city Dst JB.city}
>                    NJs = act(city: Dst
>                              load: JA.load-Weight
>                              lift: nil
>                              drop: [What]) | Js
>                 end
>              [] NewLoad = JB.load + Weight
>                 NewJob  = {AdjoinAt JB load NewLoad}
>              in
>                 NewLoad =<: Capacity
>              then
>                 NJs = NewJob | {InsertDst NewJob Jr Dst Weight What ?C}
>              end
>           end
>        end

>        proc {MakePlan Tour Task ?Cost ?NewTour}
>           Cost # NewTour = case {Search.base.best
>                                  proc {$ S}
>                                     C # NewTour = S
>                                  in
>                                     C :: 0#FD.sup
>                                     {InsertSrc Tour Task.src Task.dst Task.weight
>                                      Task.what ?C ?NewTour}
>                                  end
>                                  proc {$ SA SB} SA.1>:SB.1 end}
>                            of nil then false#Tour
>                            [] [S] then S
>                            end
>        end

>     end