Random generation of transportation tasks: Randomizer.oz

Source File

functor 
 
import 
   OS
    
   Configure(delta:    Delta
             delay:    DelayMove
             capacity: Capacity
             goods:    Goods)
   Country(cities)
 
export 
   'class': Randomizer
    
define 
 
   %% Randomizer
   local 
      Speed = (1000 * Delta) div DelayMove % Relative speed
   in 
      MedLowTime   = 20 * Speed        % Lower bound for random time interval
      MedHighTime  = 3 * MedLowTime    % Upper bound for random time interval
      SlowLowTime  = MedLowTime div 2  % Lower bound for random time interval
      SlowHighTime = MedHighTime div 2 % Upper bound for random time interval
      FastLowTime  = 2 * MedLowTime    % Lower bound for random time interval
      FastHighTime = 2 * MedHighTime   % Upper bound for random time interval
   end 
    
   LowGood  = Capacity div 10 % Lower bound for random weight of goods
   HighGood = Capacity        % Upper bound for random weight of goods
 
 
   Cities = {List.toTuple '#' Country.cities}
    
   fun {RandomDot T}
      T.({OS.rand} mod {Width T} + 1)
   end 
    
   fun {Uniform Low High}
      {OS.rand} mod (High - Low) + Low
   end 
    
   fun {DiffCity City}
      RandCity = {RandomDot Cities}
   in 
      if RandCity==City then {DiffCity City}
      else RandCity
      end 
   end 
    
   class Randomizer 
      prop 
         final locking
      attr 
         Stamp: 0
         On:    false 
         Low:   MedLowTime
         High:  MedHighTime
      feat 
         broker
       
      meth init(broker:B)
         self.broker = B
      end 
       
      meth toggle 
         case 
            lock 
               if @On then On <- false  Stamp <- @Stamp + 1 ~1
               else On <- true @Stamp
               end 
            end 
         of ~1 then skip elseof S then {self Go(S)}
         end 
      end 
       
      meth slow 
         lock Low <- SlowLowTime   High <- SlowHighTime end 
      end 
       
      meth medium 
         lock Low <- MedLowTime    High <- MedHighTime  end 
      end 
       
      meth fast 
         lock Low <- FastLowTime   High <- FastHighTime end 
      end 
       
      meth Go(S)
         CurS CurLow CurHigh
      in 
         lock 
            CurS    = @Stamp
            CurLow  = @Low
            CurHigh = @High
         end 
         if CurS==S then 
            Src={RandomDot Cities}
         in 
            {self.broker announce(src:    Src
                                  dst:    {DiffCity  Src}
                                  what:   {RandomDot Goods}
                                  weight: {Uniform LowGood HighGood})}
            {Delay {Uniform CurLow CurHigh}}
            {self Go(S)}
         end 
      end 
       
      meth close 
         lock 
            {Wait _}
         end 
      end 
       
   end 
end