m      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+, - . / 0 1 2 3 4 5!6!7!8"9":";"<"=">"?#@#A#B$C$D$E$F$G%H%I&J&K&L&M&N&O&P&Q&R&S&T&U&V&W&X&Y&Z&[&\&]&^&_&`&a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r's't'u'v'w'x'y'z'{'|'}'~''''''''''''(())))))))))))))))))))))))))))))))))))))))******************+++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, , , , , ,,,,,,,,,,,,,,,,,,, ,!-"-#-$-%-&-'-(-)-*-+-,---.-/-0-1-2-3-4-5-6-7-8-9-:-;-<-=->-?-@-A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^-_-`-a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z-{-|-}-~-----------------------------------------------------------------....................................////////0000000000000000: experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredLookup x in a table of pairs (x, y) using linear interpolation. Lookup x in a table of pairs (x, y) using stepwise function.  experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred Represents a resizable vector. Create a new vector. Copy the vector. 3Ensure that the vector has the specified capacity. Return the element count. 4Add the specified element to the end of the vector. @Read a value from the vector, where indices are started from 0. BSet an array item at the specified index which is started from 0. KReturn the index of the specified element using binary search; otherwise, J a negated insertion index minus one: 0 -> -0 - 1, ..., i -> -i - 1, .... 9Return the elements of the vector in an immutable array. 9Insert the element in the vector at the specified index. +Delete the element at the specified index. )Return the index of the item or -1.      experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredThe + type represents an imperative heap-based  priority queue. *Test whether the priority queue is empty. 5Return the number of elements in the priority queue. Create a new priority queue. 3Enqueue a new element with the specified priority. /Dequeue the element with the minimal priority. .Return the element with the minimal priority.   experimental'David Sorokin <david.sorokin@gmail.com> Safe-Inferred<The type which values can be contained in an unboxed array. -Create an unboxed array with default values.            experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred (Represents an unboxed resizable vector. Create a new vector. Copy the vector. 3Ensure that the vector has the specified capacity. Return the element count. 4Add the specified element to the end of the vector. @Read a value from the vector, where indices are started from 0. BSet an array item at the specified index which is started from 0. KReturn the index of the specified element using binary search; otherwise, J a negated insertion index minus one: 0 -> -0 - 1, ..., i -> -i - 1, .... 9Return the elements of the vector in an immutable array. 9Insert the element in the vector at the specified index. !+Delete the element at the specified index. ")Return the index of the item or -1.  !"  !"  !" !" experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred #The #3 type represents an imperative double-linked list. "A cell of the double-linked list. $ Test whether the list is empty. %+Return the number of elements in the list. &Create a new list. ''Insert a new element in the beginning. (Add a new element to the end. )Remove the first element. *Remove the last element. +Return the first element. ,Return the last element. # !"#$$%&'()*+, #$%&'()*+, #$%&'()*+, # !"#$$%&'()*+, experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred(-MDefines the data type from which values we can gather the timing statistics. .)An empty statistics that has no samples. /8Add a sample with the specified time to the statistics. 0Return the average value. 1Return the variance. 2@This is the timing statistics where data are bound to the time. 4Return the number of samples. 5Return the minimum value. 6Return the maximum value. 72Return the time at which the minimum is attained. 82Return the time at which the maximum is attained. 9#Return the start time of sampling. :"Return the last time of sampling. ;Return the sum of values. <!Return the sum of square values. =OSpecifies data type from which values we can gather the statistics. >4An empty statistics that has no samples. ?$Add a new sample to the statistics. @Combine two statistics. A8Describes when the statistics consists of only samples # not bound to the simulation time. CThe total number of samples. D%The minimum value among the samples. E%The maximum value among the samples. FThe average value. GThe average square value. %,Defines data types that can be converted to &. 'Convert the value to &. HdIf allows combining statistics more efficiently if we know that the first argument can be a scalar. IReturn the variance. J Return the deviation. K*Return the statistics by a single sample. L5Create the statistics by the specified list of data. M6Convert the statistics from integer to double values. (+Show the summary of the statistics. NFShow the summary of the statistics using the specified indent. O$Return the deviation. P-Return the statistics by single timing data. Q6Convert the statistics from integer to double values. )+Show the summary of the statistics. RFShow the summary of the statistics using the specified indent. 9-./0123456789:;<=>?@ABCDEFG%'*+HIJKLM(N,-./OPQ)R012345678&-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR&ABCDEFG=>?@HIJNKLM23456789:;<-./01ORPQ!-./012 3456789:;<=>?@ABCDEFG%'*+HIJKLM(N,-./OPQ)R012345678 experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredS/Defines a type of the random number generator. T<The custom random number generator by the specified uniform # generator of numbers from 0 to 1. U$The custom random number generator. V<The simple random number generator with the specified seed. W$The simple random number generator. X#Defines a random number generator. Z"Generate an uniform random number ) with the specified minimum and maximum. [*Generate an uniform integer random number ) with the specified minimum and maximum. \"Generate the normal random number ( with the specified mean and deviation. ]5Generate the random number distributed exponentially 7 with the specified mean (the reciprocal of the rate). ^"Generate the Erlang random number J with the specified scale (the reciprocal of the rate) and integer shape. _#Generate the Poisson random number  with the specified mean. `$Generate the binomial random number 6 with the specified probability and number of trials. 9KGenerate the uniform random number with the specified minimum and maximum. :KGenerate the uniform random number with the specified minimum and maximum. ;CCreate a normal random number generator with mean 0 and variance 1 C by the specified generator of uniform random numbers from 0 to 1. <>Return the exponential random number with the specified mean. =!Return the Erlang random number. ><Generate the Poisson random number with the specified mean. ?XGenerate a binomial random number with the specified probability and number of trials. a<Create a new random number generator by the specified type. bCCreate a new random generator by the specified standard generator. @YCreate a new random generator by the specified uniform generator of numbers from 0 to 1. STUVWXYZ[\]^_`9the generator minimum maximum :the generator minimum maximum ;the generator <the generator  the mean =the generator  the scale  the shape >the generator  the mean ?the generator the probability the number of trials ab@STUVWXYZ[\]^_`abXYZ[\]^_`SWVUTab SWVUTXYZ[\]^_`9:;<=>?ab@1 experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred)AIt represents the event queue. Bthe underlying priority queue C1whether the queue is currently processing events D#the actual time of the event queue EJIt defines the simulation point appended with the additional information. Fthe simulation specs Gthe simulation run Hthe current time Ithe current iteration Jthe current phase K#It indentifies the simulation run. Lthe simulation specs M!the current simulation run index N,the total number of runs in this experiment Othe event queue Pthe random number generator c#It defines the integration method. d!the 4th order Runge-Kutta method e!the 2nd order Runge-Kutta method fEuler' s method g!It defines the simulation specs. ithe start time jthe stop time kthe integration time step lthe integration method m(the type of the random number generator Q1Create a new event queue by the specified specs. R7Returns the integration iterations starting from zero. n3Returns the first and last integration iterations. o4Returns the first integration iteration, i.e. zero. p(Returns the last integration iteration. SJReturns the phases for the specified simulation specs starting from zero. q/Returns the first and last integration phases. r0Returns the first integration phase, i.e. zero. s/Returns the last integration phase, 0 for Euler'#s method, 1 for RK2 and 3 for RK4. tBReturns a simulation time for the integration point specified by ! the specs, iteration and phase. u$Return the integration time values. T$Return the integration time points. UReturn the start time point. VReturn the stop time point. W(Return the point at the specified time. -AXBCDEYFGHIJKZLMNOPcdefghijklmQRnopSqrstuTUVW+AXBCDEYFGHIJKZLMNOPcdefghijklmQnopqrstuTUVWAXBCDEYFGHIJKZLMNOPcfedghijklmQRnopSqrstuTUVW  experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferredcdefghijklmnopqrstughijklmcfedtnpoqsru2 experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferredv;A type class to lift the parameters to other computations. wLift the specified x% computation to another computation. xThe x4 monad that allows specifying the model parameters. H For example, they can be used when running the Monte-Carlo simulation. WIn general, this monad is very useful for representing a computation which is external  relative to the model itself. y-Run the parameter using the specified specs. z?Run the given number of parameters using the specified specs, 6 where each parameter is distinguished by its index parameterIndex. {1Return the run index for the current simulation. |0Return the number of simulations currently run. }Return the simulation specs. ~;Return the random number generator for the simulation run. Exception handling within x computations. .A computation with finalization part like the [ function. Like the standard \ function. ] Invoke the x computation.  Memoize the x. computation, always returning the same value L within a simulation run. However, the value will be recalculated for other H simulation runs. Also it is thread-safe when different simulation runs L are executed in parallel on physically different operating system threads. NReturn a parameter which value is taken consequently from the specified table P based on the run index of the current simulation starting from zero. After all N values from the table are used, it takes again the first value of the table,  then the second one and so on. 4Computation that returns the start simulation time. 4Computation that returns the final simulation time. 4Computation that returns the integration time step. "vwx^_`yz{|}~ab]cdefghijklmvwx^yz{|}~] vwx^_`yz{|}~ab]cdefghijklm  experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferredvwxyz{|}~xvwyz{|}~3 experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred HA type class to lift the simulation computations to other computations. Lift the specified % computation to another computation. A value in the  monad represents a computation  within the simulation run. .Run the simulation using the specified specs. @Run the given number of simulations using the specified specs, 7 where each simulation is distinguished by its index {. nReturn the event queue. Exception handling within  computations. .A computation with finalization part like the [ function. Like the standard \ function. o Invoke the  computation.  Memoize the . computation, always returning the same value  within a simulation run. pqrnstouvwxyz{ pnopqrnstouvwxyz{  experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred 4 experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredA type class to lift the % computations to other computations. Lift the specified % computation to another computation. A value in the 7 monad represents a polymorphic time varying function. Run the ( computation in the initial time point. Run the & computation in the final time point. Run the - computation in all integration time points. Run the * computation in the specified time point. Run the + computation in the specified time points. Exception handling within  computations. .A computation with finalization part like the [ function. Like the standard \ function. | Invoke the  computation. 6Computation that returns the current simulation time. 1Whether the current time is an integration time. IReturn the integration iteration closest to the current simulation time. >Return the integration phase for the current simulation time.  It is (-1)" for non-integration time points. $}~|}|"}~|5 experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred&-Defines a computation disposing some entity. Dispose something within the  computation.  It allows cancelling the event. Cancel the event. &Test whether the event was cancelled. 3Test whether the event was processed and finished. &Defines how the events are processed. #either process all earlier events, 6 or do nothing if the current simulation time is less ) than the actual time of the event queue ; (do not use unless the documentation states the opposite) 4either process all earlier and then current events, 6 or do nothing if the current simulation time is less ) than the actual time of the event queue ; (do not use unless the documentation states the opposite) 0either process all earlier events not affecting , the events at the current simulation time, : or raise an error if the current simulation time is less 6 than the actual time of the event queue (safe within  the 6 computation as this is protected by the type system) 4either process all earlier and then current events, : or raise an error if the current simulation time is less 6 than the actual time of the event queue (safe within  the 6 computation as this is protected by the type system) A type class to lift the $ computation to other computations. Lift the specified % computation to another computation. A value in the 6 monad represents a polymorphic time varying function 6 which is strongly synchronized with the event queue. Exception handling within  computations. .A computation with finalization part like the [ function. Like the standard \ function.  Invoke the  computation. @Enqueue the event which must be actuated at the specified time. *The events are processed when calling the  function. So, G if you want to insist on their immediate execution then you can apply  something like   > liftDynamics $ runEvent IncludingCurrentEvents $ return () ,although this is generally not good idea. Process the pending events. =Process the pending events synchronously, i.e. without past. A memoized value. A memoized value. A memoized value. A memoized value. Process the events. Run the , computation in the current simulation time  within the # computation involving all pending   in the processing too. Run the , computation in the current simulation time  within the - computation specifying what pending events ' should be involved in the processing. Run the - computation in the start time involving all  pending  in the processing too. Run the , computation in the stop time involving all  pending  in the processing too. 0Return the number of pending events that should  be yet actuated. 8Actuate the event handler in the specified time points. 8Actuate the event handler in the specified time points. :Actuate the event handler in the integration time points. 0Enqueue the event with an ability to cancel it.  Memoize the . computation, always returning the same value  within a simulation run.  Memoize the . computation, always returning the same value A in the same modeling time. After the time changes, the value is  recalculated by demand. ?It is possible to implement this function efficiently, for the  D computation is always synchronized with the event queue which time G flows in one direction only. This synchronization is a key difference  between the  and  computations. SEnqueue the event which must be actuated with the current modeling time but later. 9!- experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredThe 3 type represents a mutable variable similar to the  variable Q but only dependent on the event queue, which allows synchronizing the reference ' with the model explicitly through the  monad. Create a new reference. Read the value of a reference. &Write a new value into the reference. &Mutate the contents of the reference.   experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred! experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred9Strategy: Static Priorities. It uses the priority queue. *Strategy: Service in Random Order (SIRO). *Strategy: Last Come - First Served (LCFS) ,Strategy: First Come - First Served (FCFS). RIt defines a strategy when we can enqueue an element with the specified priority. 0Enqueue an element with the specified priority. <It defines a strategy when we can enqueue a single element. Enqueue an element. <Defines a strategy with support of the dequeuing operation. )Dequeue the front element and return it. "Defines the basic queue strategy. A queue used by the strategy. .Create a new queue by the specified strategy. !Test whether the queue is empty. An implementation of the  queue strategy. An implementation of the  queue strategy. An implementation of the  queue strategy. An implementation of the  queue strategy. An implementation of the  queue strategy. An implementation of the  queue strategy. An implementation of the  queue strategy. An implementation of the  queue strategy. An implementation of the  queue strategy. An implementation of the  queue strategy. An implementation of the  queue strategy. An implementation of the  queue strategy.  the queue  the priority the element to be enqueued the action of enqueuing  the queue the element to be enqueued the action of enqueuing  the queue the dequeued element  the strategy  a new queue  the queue the result of the test 6 experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredOIt defines when an event has arrived, usually generated by some random stream. MSuch events should arrive one by one without time lag in the following sense J that the model should start awaiting the next event exactly in that time & when the previous event has arrived. OAnother use case is a situation when the actual event is not synchronized with  the E computation, being synchronized with the event queue, nevertheless. R Then the arrival is used for providing the additional information about the time / at which the event had been actually arrived. $the data we received with the event 3the simulation time at which the event has arrived 1the delay time which has passed from the time of  arriving the previous event 7 experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred'CDescribes a computation that also signals when changing its value. #Return a computation of the value. 5Return a signal notifying that the value has changed @ but without providing the information about the changed value. -Represents the history of the signal values. -The signal for which the history is created. @It contains the information about the disposable queue handler. The queue of signal handlers. 0The signal that can have disposable handlers. (Subscribe the handler to the specified ( signal and return a nested computation 1 within a disposable object that, being applied, , unsubscribes the handler from this signal. /The signal source that can publish its signal. Publish the signal. Trigger the signal actuating " all its handlers at the current  simulation time point. 7Subscribe the handler to the specified signal forever. 4 To subscribe the disposable handlers, use function . Create a new signal source. "Trigger all next signal handlers. LEnqueue the handler and return its representative in the queue. $Dequeue the handler representative. 1Map the signal according the specified function. 1Filter only those signal values that satisfy to  the specified predicate. 1Filter only those signal values that satisfy to  the specified predicate. Merge two signals. Merge three signals. Merge four signals. Merge five signals. Compose the signal. Transform the signal. *An empty signal which is never triggered. 'Create a history of the signal values. 4Create a history of the signal values starting with  the optional initial value. #Read the history of signal values. *Trigger the signal with the current time. @Return a signal that is triggered in the specified time points. BReturn a signal that is triggered in the integration time points. " It should be called with help of . 5Return a signal that is triggered in the start time. " It should be called with help of . 5Return a signal that is triggered in the final time. 6Return a signal notifying that the value has changed. Return an identity. An associative operation. OTransform a signal so that the resulting signal returns a sequence of arrivals Y saving the information about the time points at which the original signal was received. 7#& experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred#& experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredThe 3 type represents a mutable variable similar to the  variable Q but only dependent on the event queue, which allows synchronizing the reference ' with the model explicitly through the  monad. Create a new reference. Read the value of a reference. &Write a new value into the reference. &Mutate the contents of the reference. IReturn a signal that notifies about every change of the reference state. IReturn a signal that notifies about every change of the reference state.  experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred  Like the 0 reference but keeps the history of changes in  different time points. The  variable is safe to be used in , the hybrid discrete-continuous simulation. >For example, the memoised values of a variable can be used in D the differential or difference equations of System Dynamics, while H the variable iself can be updated wihin the discrete event simulation. 6Only this variable is much slower than the reference. Create a new variable. QRead the first actual, i.e. memoised, value of a variable for the requested time 8 actuating the current events from the queue if needed. >This computation can be used in the ordinary differential and * difference equations of System Dynamics. CRead the recent actual value of a variable for the requested time. IThis computation is destined for using within discrete event simulation. %Write a new value into the variable. %Mutate the contents of the variable.  KFreeze the variable and return in arrays the time points and corresponded M first and last values when the variable had changed or had been memoised in K different time points: (1) the time points are sorted in ascending order; H (2) the first and last actual values per each time point are provided. PIf you need to get all changes including those ones that correspond to the same - simulation time points then you can use the  function passing  in the  % signal to it and then call function .  HReturn a signal that notifies about every change of the variable state.  HReturn a signal that notifies about every change of the variable state.              experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred   Like the 0 reference but keeps the history of changes in  different time points. The   variable is safe to be used in , the hybrid discrete-continuous simulation. >For example, the memoised values of a variable can be used in D the differential or difference equations of System Dynamics, while H the variable iself can be updated wihin the discrete event simulation. 6Only this variable is much slower than the reference.  Create a new variable. QRead the first actual, i.e. memoised, value of a variable for the requested time 8 actuating the current events from the queue if needed. >This computation can be used in the ordinary differential and * difference equations of System Dynamics. CRead the recent actual value of a variable for the requested time. IThis computation is destined for using within discrete event simulation. %Write a new value into the variable. %Mutate the contents of the variable. KFreeze the variable and return in arrays the time points and corresponded M first and last values when the variable had changed or had been memoised in K different time points: (1) the time points are sorted in ascending order; H (2) the first and last actual values per each time point are provided. PIf you need to get all changes including those ones that correspond to the same - simulation time points then you can use the  function passing  in the % signal to it and then call function . HReturn a signal that notifies about every change of the variable state. HReturn a signal that notifies about every change of the variable state.            8 experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred&'The auxiliary continuation parameters. The continuation parameters. The - type is similar to the standard Cont monad  and F#0 async workflow but only the result of applying  the continuations return the  computation. %It manages the cancellation process. FIt defines how the parent and child computations should be cancelled. &Cancel the computations in isolation. -Cancel the parent if its child is cancelled. -Cancel the child if its parent is cancelled. 'Cancel the both computations together.  Create the cancellation source. +Signal when the cancellation is intiating. (Whether the cancellation was initiated. (Whether the cancellation was activated. Deactivate the cancellation. UIf the main computation is cancelled then all the nested ones will be cancelled too. 1Connect the parent computation to the child one. Initiate the cancellation. Invoke the computation. Cancel the computation. Like return a >>= k. Exception handling within  computations. &A computation with finalization part. 9Throw the exception with the further exception handling. >By some reason, an exception raised with help of the standard \ function  is not handled properly within 0 computation, altough it will be still handled  if it will be wrapped in the . monad. Therefore, you should use specialised , functions like the stated one that use the \ function but within the  computation, . which allows already handling the exception. Run the 4 computation with the specified cancelation source E and flag indicating whether to catch exceptions from the beginning.  Lift the x computation.  Lift the  computation.  Lift the  computation.  Lift the  computation. Lift the IO computation. 4Resume the computation by the specified parameters. ;Resume the exception handling by the specified parameters. *Test whether the computation is canceled. 6Execute the specified computations in parallel within D the current computation and return their results. The cancellation D of any of the nested computations affects the current computation. F The exception raised in any of the nested computations is propogated B to the current computation as well (if the exception handling is  supported).  Here word parallel+ literally means that the computations are ; actually executed on a single operating system thread but 7 they are processed simultaneously by the event queue. A partial case of  when we are not interested in D the results but we are interested in the actions to be peformed by  the nested computations.  Rerun the 5 computation with the specified cancellation source. Run the ? computation in parallel but connect the cancellation sources. /Freeze the computation parameters temporarily. Await the signal. @      the parent how to connect  the child &computation of the disposable handler the computation to run the main branch "the branch for handing exceptions the branch for cancellation the cancellation source =whether to support the exception handling from the beginning  the list of:  the nested computation,  the cancellation source  the list of:  the nested computation,  the cancellation source  .     9 experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred1The result of memoization. A type class to lift the $ computation to other computations. Lift the specified % computation to another computation. ?Specifies a discontinuous process that can suspend at any time  and then resume later. !Represents a process identifier.  Invoke the process computation. 0Hold the process for the specified time period.  AInterrupt a process with the specified identifier if the process  is held by computation . !HTest whether the process with the specified identifier was interrupted. "Passivate the process. #FTest whether the process with the specified identifier is passivated. $4Reactivate a process with the specified identifier. .Prepare the processes identifier for running. %#Run immediately the process. A new  identifier will be  assigned to the process. 6To run the process at the specified time, you can use  the + function. &;Run immediately the process with the specified identifier. L It will be more efficient than as you would specify the process identifier  with help of the ; combinator and then would call %. 6To run the process at the specified time, you can use  the , function. 'DRun the process in the start time immediately involving all pending   in the computation too. (MRun the process in the start time immediately using the specified identifier  and involving all pending  in the computation too. )GRun the process in the final simulation time immediately involving all  pending  in the computation too. *@Run the process in the final simulation time immediately using 4 the specified identifier and involving all pending   in the computation too. +DEnqueue the process that will be then started at the specified time  from the event queue. ,DEnqueue the process that will be then started at the specified time  from the event queue. -'Return the current process identifier. .!Create a new process identifier. /KCancel a process with the specified identifier, interrupting it if needed. 0The process cancels itself. 1FTest whether the process with the specified identifier was cancelled. 2AReturn a signal that notifies about cancelling the process with  the specified identifier. 3SRegister a handler that will be invoked in case of cancelling the current process. 4Exception handling within  computations. 5&A computation with finalization part. 69Throw the exception with the further exception handling. >By some reason, an exception raised with help of the standard \ function  is not handled properly within 0 computation, altough it will be still handled  if it will be wrapped in the . monad. Therefore, you should use specialised , functions like the stated one that use the \ function but within the  computation, . which allows already handling the exception. 76Execute the specified computations in parallel within D the current computation and return their results. The cancellation D of any of the nested computations affects the current computation. F The exception raised in any of the nested computations is propagated % to the current computation as well.  Here word parallel+ literally means that the computations are ; actually executed on a single operating system thread but 7 they are processed simultaneously by the event queue. New 8 identifiers will be assigned to the started processes. 8Like 70 but allows specifying the process identifiers. M It will be more efficient than as you would specify the process identifiers  with help of the ; combinator and then would call 7. 9Like 7 but ignores the result. :Like 8 but ignores the result. $Create the new process identifiers. .Prepare the processes for parallel execution. ;9Allow calling the process with the specified identifier. F It creates a nested process when canceling any of two, or raising an  IO+ exception in any of the both, affects the  computation. EAt the same time, the interruption has no such effect as it requires  explicit specifying the * identifier of the nested process itself, H that is the nested process cannot be interrupted using only the parent  process identifier. <FSpawn the child process specifying how the child and parent processes & should be cancelled in case of need. =FSpawn the child process specifying how the child and parent processes & should be cancelled in case of need. >Await the signal. ?BMemoize the process so that it would always return the same value  within the simulation run. @1Zip two parallel processes waiting for the both. A8Zip three parallel processes waiting for their results. B>Unzip the process using memoization so that the both returned D processes could be applied independently, although they will refer  to the same pair of values. C;Try to run the child process within the specified timeout. H If the process will finish successfully within this time interval then  the result wrapped in  0 will be returned; otherwise, the child process  will be cancelled and ! will be returned. HIf an exception is raised in the child process then it is propagated to ! the parent computation as well. )A cancellation of the child process doesn')t lead to cancelling the parent process.  Then !% is returned within the computation. DUTry to run the child process with the given identifier within the specified timeout. H If the process will finish successfully within this time interval then  the result wrapped in  0 will be returned; otherwise, the child process  will be cancelled and ! will be returned. HIf an exception is raised in the child process then it is propagated to ! the parent computation as well. )A cancellation of the child process doesn')t lead to cancelling the parent process.  Then !% is returned within the computation. EYield to allow other  and  computations to run ' at the current simulation time point. FOA computation that never computes the result. It behaves like a black hole for R the discontinuous process, although such a process can still be canceled outside  (see /-), but then only its finalization parts (see 5) D will be called, usually, to release the resources acquired before. M"#$%&'()*+, !"#$%&'()*+,-./0123-./0123456789:;<=>?@ABCDEF456789:;<=.% !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFA$#"%&'()*+, !"#$%&'()*+,-./0123-./0123456789:;<=>?@ABCDEF456789:;<= experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred, !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF,%&'()*<=+,.-; !"#$/0123>ECD789:456@AB?F experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredG&Represents the resource with strategy s# applied for queuing the requests. H6Return the strategy applied for queuing the requests. I0Return the maximum count of the resource, where ! - means that the resource has no upper bound. J%The resource with static priorities. K.The SIRO (Serviced in Random Order) resource. L9The ordinary LCFS (Last Come - First Serviced) resource. M:The ordinary FCFS (First Come - First Serviced) resource. NPCreate a new FCFS resource with the specified initial count which value becomes  the upper bound as well. OJCreate a new FCFS resource with the specified initial and maximum counts,  where !- means that the resource has no upper bound. PPCreate a new LCFS resource with the specified initial count which value becomes  the upper bound as well. QJCreate a new LCFS resource with the specified initial and maximum counts,  where !- means that the resource has no upper bound. RPCreate a new SIRO resource with the specified initial count which value becomes  the upper bound as well. SJCreate a new SIRO resource with the specified initial and maximum counts,  where !- means that the resource has no upper bound. TTCreate a new priority resource with the specified initial count which value becomes  the upper bound as well. UNCreate a new priority resource with the specified initial and maximum counts,  where !- means that the resource has no upper bound. VKCreate a new resource with the specified queue strategy and initial count. 1 The last value becomes the upper bound as well. WUCreate a new resource with the specified queue strategy, initial and maximum counts,  where !- means that the resource has no upper bound. X*Return the current count of the resource. YBRequest for the resource decreasing its count in case of success, B otherwise suspending the discontinuous process until some other  process releases the resource. Z@Request with the priority for the resource decreasing its count D in case of success, otherwise suspending the discontinuous process 1 until some other process releases the resource. [BRelease the resource increasing its count and resuming one of the - previously suspended processes as possible. \BRelease the resource increasing its count and resuming one of the - previously suspended processes as possible. ]HTry to request for the resource decreasing its count in case of success  and returning > in the  monad; otherwise, returning ?. ^YAcquire the resource, perform some action and safely release the resource  in the end, even if the @ was raised within the action. _JAcquire the resource with the specified priority, perform some action and 5 safely release the resource in the end, even if the @ was raised  within the action. GAHIBCJKLMN:the initial count (and maximal count too) of the resource O"the initial count of the resource ;the maximum count of the resource, which can be indefinite P:the initial count (and maximal count too) of the resource Q"the initial count of the resource ;the maximum count of the resource, which can be indefinite R:the initial count (and maximal count too) of the resource S"the initial count of the resource ;the maximum count of the resource, which can be indefinite T:the initial count (and maximal count too) of the resource U"the initial count of the resource ;the maximum count of the resource, which can be indefinite V/the strategy for managing the queuing requests :the initial count (and maximal count too) of the resource W/the strategy for managing the queuing requests "the initial count of the resource ;the maximum count of the resource, which can be indefinite XYthe requested resource Zthe requested resource  the priority [the resource to release \the resource to release ])the resource which we try to request for ^Ethe resource we are going to request for and then release in the end 5the action we are going to apply having the resource the result of the action _2the resource we are going to request for and then  release in the end  the priority 5the action we are going to apply having the resource the result of the action DGHIJKLMNOPQRSTUVWXYZ[\]^_MLKJGHINOPQRSTUVWHIXYZ][\^_GAHIBCJKLMNOPQRSTUVWXYZ[\]^_D experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred`#Represents the result of the task. athe task was cancelled b=the specified exception was raised when performing the task. c(the task was successfully completed and " it returned the specified result dFThe task represents a process that was already started in background. e7Return an identifier for the process that was launched  in background for this task. E+It contains the result of the computation. f.Return a signal that notifies about receiving  the result of the task. g;Try to get the task result immediately without suspension. hAReturn the task result suspending the outer process if required. iCancel the task. j%Test whether the task was cancelled. F;Create a task by the specified process and its identifier. k@Run the process with the specified identifier in background and + return the corresponded task immediately. lLRun the process in background and return the corresponded task immediately. mNEnqueue the process that will be started at the specified time with the given P identifier from the event queue. It returns the corresponded task immediately. nUEnqueue the process that will be started at the specified time from the event queue. / It returns the corresponded task immediately. oLRun using the specified identifier a child process in background and return $ immediately the corresponded task. pPRun a child process in background and return immediately the corresponded task. qPReturn an outer process that behaves like the task itself except for one thing: N if the outer process is cancelled then it is not enough to cancel the task. `abcdGeEfghijFklmnopq`abcdefghijklmnopqdef`cbaeghfqijlkponm`cbadGeEfghijFklmnopq experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred^H.Stores the item and a time of its enqueuing. IReturn the item value. J'Return the time of enqueuing the item. K,Return the time of storing in the queue, or   itemInputTime before the actual storing when  the item was just enqueued. rJRepresents a queue using the specified strategies for enqueueing (input), si,  internal storing (in memory), sm, and dequeueing (output), so, where a denotes ( the type of items stored in the queue. sThe queue capacity. tQThe strategy applied to the enqueueing (input) processes when the queue is full. uBThe strategy applied when storing (in memory) items in the queue. vSThe strategy applied to the dequeueing (output) processes when the queue is empty. wAA type synonym for the queue with static priorities applied when $ storing the elements in the queue. x>A type synonym for the SIRO (Serviced in Random Order) queue. yBA type synonym for the ordinary LIFO queue also known as the LCFS % (Last Come - First Serviced) queue. zBA type synonym for the ordinary FIFO queue also known as the FCFS & (First Come - First Serviced) queue. {7Create a new FCFS queue with the specified capacity. |7Create a new LCFS queue with the specified capacity. }7Create a new SIRO queue with the specified capacity. ~;Create a new priority queue with the specified capacity. ACreate a new queue with the specified strategies and capacity. !Test whether the queue is empty.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed.  Test whether the queue is full.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. Return the current queue size.  See also ,  and . "Return the queue size statistics. Signal when the  property value has changed. Signal when the  property value has changed. ;Return the total number of input items that were enqueued.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. !Return the number of lost items.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. 9Return the total number of input items that were stored.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. >Return the total number of requests for dequeueing the items, D not taking into account the failed attempts to dequeue immediately  without suspension.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. EReturn the total number of output items that were actually dequeued.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. DReturn the load factor: the queue size divided by its maximum size.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. FReturn the rate of the input items that were enqueued: how many items  per time. >Return the rate of the items that were stored: how many items  per time. LReturn the rate of the requests for dequeueing the items: how many requests J per time. It does not include the failed attempts to dequeue immediately  without suspension. PReturn the rate of the output items that were actually dequeued: how many items  per time. PReturn the wait time from the time at which the item was stored in the queue to $ the time at which it was dequeued.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. KReturn the total wait time from the time at which the enqueueing operation ; was initiated to the time at which the item was dequeued. In some sense, 8queueTotalWaitTime == queueInputWaitTime + queueWaitTime.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. MReturn the enqueue wait time from the time at which the enqueueing operation F was initiated to the time at which the item was stored in the queue.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. KReturn the dequeue wait time from the time at which the item was requested ? for dequeueing to the time at which it was actually dequeued.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. 4Return a long-term average queue rate calculated as : the average queue size divided by the average wait time. DThis value may be less than the actual arrival rate as the queue is E finite and new arrivals may be locked while the queue remains full.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. 6Dequeue suspending the process if the queue is empty. ODequeue with the output priority suspending the process if the queue is empty. Try to dequeue immediately. @Enqueue the item suspending the process if the queue is full. XEnqueue with the input priority the item suspending the process if the queue is full. ZEnqueue with the storing priority the item suspending the process if the queue is full. fEnqueue with the input and storing priorities the item suspending the process if the queue is full.  Try to enqueue the item. Return ?$ in the monad if the queue is full. :Try to enqueue with the storing priority the item. Return ? in ! the monad if the queue is full. ITry to enqueue the item. If the queue is full then the item will be lost  and ? will be returned. HTry to enqueue with the storing priority the item. If the queue is full  then the item will be lost and ? will be returned. JTry to enqueue the item. If the queue is full then the item will be lost. HTry to enqueue with the storing priority the item. If the queue is full  then the item will be lost. IReturn a signal that notifies when the enqueuing operation is initiated. HReturn a signal that notifies when the enqueuing operation is completed = and the item is stored in the internal memory of the queue. <Return a signal which notifies that the item was lost when 5 attempting to add it to the full queue with help of  , ! or similar functions that imply ? that the element can be lost. All their names are ending with OrLost  or OrLost_. LIn other cases the enqueued items are not lost but the corresponded process N can suspend until the internal queue storage is freed. Although there is one N exception from this rule. If the process trying to enqueue a new element was % suspended but then canceled through 0 from the outside then  the item will not be added. JReturn a signal that notifies when the dequeuing operation was requested. LReturn a signal that notifies when the item was extracted from the internal U storage of the queue and prepared for immediate receiving by the dequeuing process. L,Initiate the process of enqueuing the item. MStore the item. N"Store with the priority the item. ODeny the enqueuing. PJUpdate the statistics for the input wait time of the enqueuing operation. QEAccept the dequeuing request and return the current simulation time. R-Extract an item for the dequeuing request. SJUpdate the statistics for the output wait time of the dequeuing operation , and the wait time of storing in the queue. Wait while the queue is full. 3Signal whenever any property of the queue changes. OThe property must have the corresponded signal. There are also characteristics U similar to the properties but that have no signals. As a rule, such characteristics L already depend on the simulation time and therefore they may change at any  time point. 8Return the summary for the queue with desciption of its 7 properties and activities using the specified indent. sHTIJKrUstuvVWXYZ[\]^_`abcdefghwxyz{|}~Pthe strategy applied to the enqueueing (input) processes when the queue is full 5the strategy applied when storing items in the queue Rthe strategy applied to the dequeueing (output) processes when the queue is empty the queue capacity  the queue the dequeued value  the queue the priority for output the dequeued value  the queue the dequeued value of !  the queue the item to enqueue  the queue the priority for input the item to enqueue  the queue the priority for storing the item to enqueue  the queue the priority for input the priority for storing the item to enqueue  the queue !the item which we try to enqueue  the queue the priority for storing !the item which we try to enqueue  the queue !the item which we try to enqueue  the queue the priority for storing !the item which we try to enqueue  the queue !the item which we try to enqueue  the queue the priority for storing !the item which we try to enqueue L the queue the item to be enqueued M the queue the item to be stored N the queue the priority for storing the item to be enqueued O the queue the item to be denied P the queue the item and its input time &the action of updating the statistics Q the queue the current time R the queue "the time of the dequeuing request the dequeued value S the queue "the time of the dequeuing request the item and its input time &the action of updating the statistics Rrstuvwxyz{|}~Vzyxwrstuv{|}~tuvsWHTIJKrUstuvVWXYZ[\]^_`abcdefghwxyz{|}~LMNOPQRS experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred:i.Stores the item and a time of its enqueuing. jReturn the item value. k)Return the time of storing in the queue. @Represents an infinite queue using the specified strategies for  internal storing (in memory), sm, and dequeueing (output), so, where a denotes ( the type of items stored in the queue. BThe strategy applied when storing (in memory) items in the queue. ;The strategy applied to the dequeueing (output) processes. AA type synonym for the queue with static priorities applied when $ storing the elements in the queue. >A type synonym for the SIRO (Serviced in Random Order) queue. BA type synonym for the ordinary LIFO queue also known as the LCFS % (Last Come - First Serviced) queue. BA type synonym for the ordinary FIFO queue also known as the FCFS & (First Come - First Serviced) queue. $Create a new infinite FCFS queue. $Create a new infinite LCFS queue. $Create a new infinite SIRO queue. (Create a new infinite priority queue. =Create a new infinite queue with the specified strategies. !Test whether the queue is empty.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. Return the current queue size.  See also ,  and . "Return the queue size statistics. Signal when the  property value has changed. Signal when the  property value has changed. 9Return the total number of input items that were stored.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. >Return the total number of requests for dequeueing the items, D not taking into account the failed attempts to dequeue immediately  without suspension.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. EReturn the total number of output items that were actually dequeued.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. >Return the rate of the items that were stored: how many items  per time. LReturn the rate of the requests for dequeueing the items: how many requests J per time. It does not include the failed attempts to dequeue immediately  without suspension. GReturn the rate of the output items that were dequeued: how many items  per time. PReturn the wait time from the time at which the item was stored in the queue to $ the time at which it was dequeued.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. KReturn the dequeue wait time from the time at which the item was requested ? for dequeueing to the time at which it was actually dequeued.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. 4Return a long-term average queue rate calculated as : the average queue size divided by the average wait time.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. 6Dequeue suspending the process if the queue is empty. ODequeue with the output priority suspending the process if the queue is empty. Try to dequeue immediately. Enqueue the item. .Enqueue with the storing priority the item. 5Return a signal that notifies when the enqueued item 0 is stored in the internal memory of the queue. JReturn a signal that notifies when the dequeuing operation was requested. LReturn a signal that notifies when the item was extracted from the internal U storage of the queue and prepared for immediate receiving by the dequeuing process. lStore the item. m"Store with the priority the item. nEAccept the dequeuing request and return the current simulation time. o-Extract an item for the dequeuing request. pJUpdate the statistics for the output wait time of the dequeuing operation , and the wait time of storing in the queue. 3Signal whenever any property of the queue changes. OThe property must have the corresponded signal. There are also characteristics U similar to the properties but that have no signals. As a rule, such characteristics L already depend on the simulation time and therefore they may change at any  time point. 8Return the summary for the queue with desciption of its 7 properties and activities using the specified indent. Hiqjkrstuvwxyz{|}~5the strategy applied when storing items in the queue Rthe strategy applied to the dequeueing (output) processes when the queue is empty  the queue the dequeued value  the queue the priority for output the dequeued value  the queue the dequeued value of !  the queue the item to enqueue  the queue the priority for storing the item to enqueue l the queue the item to be stored m the queue the priority for storing the item to be enqueued n the queue the current time o the queue "the time of the dequeuing request the dequeued value p the queue "the time of the dequeuing request the item and its input time &the action of updating the statistics 246iqjkrstuvwxyz{|}~lmnop experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredReturn the initial value. ;Discretize the computation in the integration time points. GInterpolate the computation based on the integration time points only.  Unlike the + function it knows about the intermediate 6 time points that are used in the Runge-Kutta method. Like the standard $ function but applied to values in E the integration time points. The accumulator values are transformed D according to the second argument, which should be either function   memo0Dynamics or its unboxed version. Like the standard $ function but applied to values in E the integration time points. The accumulator values are transformed B according to the third argument, which should be either function   memo0Dynamics or its unboxed version.  experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred*Create a boxed array with default values. HMemoize and order the computation in the integration time points using H the interpolation that knows of the Runge-Kutta method. The values are ' calculated sequentially starting from . HMemoize and order the computation in the integration time points using  the 1 interpolation. It consumes less memory than the  K function but it is not aware of the Runge-Kutta method. There is a subtle G difference when we request for values in the intermediate time points H that are used by this method to integrate. In general case you should  prefer the  function above . ?Iterate sequentially the dynamic process with side effects in @ the integration time points. It is equivalent to a call of the  ; function but significantly more efficient, for the array  is not created. 9Memoize and unzip the computation of pairs, applying the  function. 9Memoize and unzip the computation of pairs, applying the  function.  experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredHMemoize and order the computation in the integration time points using H the interpolation that knows of the Runge-Kutta method. The values are ' calculated sequentially starting from . HMemoize and order the computation in the integration time points using  the 1 interpolation. It consumes less memory than the  K function but it is not aware of the Runge-Kutta method. There is a subtle G difference when we request for values in the intermediate time points H that are used by this method to integrate. In general case you should  prefer the  function above .  experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredDComputation that generates random numbers distributed uniformly and / memoizes them in the integration time points. LComputation that generates random integer numbers distributed uniformly and / memoizes them in the integration time points. CComputation that generates random numbers distributed normally and / memoizes them in the integration time points. NComputation that generates exponential random numbers with the specified mean P (the reciprocal of the rate) and memoizes them in the integration time points. NComputation that generates the Erlang random numbers with the specified scale U (the reciprocal of the rate) and integer shape but memoizes them in the integration  time points. MComputation that generats the Poisson random numbers with the specified mean 3 and memoizes them in the integration time points. FComputation that generates binomial random numbers with the specified J probability and trials but memoizes them in the integration time points. minimum maximum minimum maximum mean  deviation &the mean (the reciprocal of the rate) 'the scale (the reciprocal of the rate)  the shape  the mean the probability the number of trials  experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred# Compare for equality.  Compare for inequality.  Compare for ordering.  Compare for ordering.  Compare for ordering. Compare for ordering. Return the maximum. Return the minimum. %Implement the if-then-else operator. DReturn an integral with the specified derivative and initial value. @To create a loopback, you should use the recursive do-notation. < It allows defining the differential equations unordered as  in mathematics:   model :: Simulation [Double]  model =  mdo a <- integ (- ka * a) 100  b <- integ (ka * a - kb * b) 0  c <- integ (kb * b) 0  let ka = 1  kb = 1 0 runDynamicsInStopTime $ sequence [a, b, c] +Return the first order exponential smooth. ?To create a loopback, you should use the recursive do-notation 4 with help of which the function itself is defined:   smoothI x t i =  mdo y <- integ ((x - y) / t) i  return y +Return the first order exponential smooth. $This is a simplified version of the  function & without specifing the initial value. +Return the third order exponential smooth. ?To create a loopback, you should use the recursive do-notation 4 with help of which the function itself is defined:   smooth3I x t i =  mdo y <- integ ((s2 - y) / t') i  s2 <- integ ((s1 - s2) / t') i  s1 <- integ ((x - s1) / t') i  let t' = t / 3.0  return y +Return the third order exponential smooth. $This is a simplified version of the  function ' without specifying the initial value.  Return the n'th order exponential smooth. XThe result is not discrete in that sense that it may change within the integration time O interval depending on the integration method used. Probably, you should apply  the > function to the result if you want to achieve an effect when M the value is not changed within the time interval, which is used sometimes.  Return the n'th order exponential smooth. $This is a simplified version of the  function ' without specifying the initial value. *Return the first order exponential delay. ?To create a loopback, you should use the recursive do-notation 4 with help of which the function itself is defined:   delay1I x t i =  mdo y <- integ (x - y / t) (i * t)  return $ y / t *Return the first order exponential delay. $This is a simplified version of the  function ' without specifying the initial value. *Return the third order exponential delay. *Return the third order exponential delay. $This is a simplified version of the  function ' without specifying the initial value.  Return the n'th order exponential delay.  Return the n'th order exponential delay. $This is a simplified version of the  function ' without specifying the initial value. Return the forecast. +The function has the following definition:   forecast x at hz =  do y <- smooth x at  return $ x * (1.0 + (x / y - 1.0) / at * hz)  Return the trend. +The function has the following definition:   trend x at i =  do y <- smoothI x at (x / (1.0 + i * at))  return $ (x / y - 1.0) / at !+Retun the sum for the difference equation. ( It is like an integral returned by the  function, only now / the difference is used instead of derivative. JAs usual, to create a loopback, you should use the recursive do-notation. "Lookup x in a table of pairs (x, y) using linear interpolation. #Lookup x in a table of pairs (x, y) using stepwise function. $7Return the delayed value using the specified lag time. %IReturn the delayed value using the specified lag time and initial value. 8 Because of the latter, it allows creating a loop back. &NReturn the Net Present Value (NPV) of the stream computed using the specified ? discount rate, the initial value and some factor (usually 1). $It is defined in the following way:   npv stream rate init factor =  mdo let dt' = liftParameter dt  df <- integ (- df * rate) 1  accum <- integ (stream * df) init  return $ (accum + dt' * stream * df) * factor 'IReturn the Net Present Value End of period (NPVE) of the stream computed G using the specified discount rate, the initial value and some factor. $It is defined in the following way:   npve stream rate init factor =  mdo let dt' = liftParameter dt  df <- integ (- df * rate / (1 + rate * dt')) (1 / (1 + rate * dt'))  accum <- integ (stream * df) init  return $ (accum + dt' * stream * df) * factor (VComputation that returns 0 until the step time and then returns the specified height. )UComputation that returns 1, starting at the time start, and lasting for the interval * width; 0 is returned at all other times. *UComputation that returns 1, starting at the time start, and lasting for the interval U width and then repeats this pattern with the specified period; 0 is returned at all  other times. +CComputation that returns 0 until the specified time start and then ; slopes upward until the end time and then holds constant. &     the derivative the initial value  the integral the value to smooth over time time the initial value #the first order exponential smooth the value to smooth over time time #the first order exponential smooth the value to smooth over time time the initial value #the third order exponential smooth the value to smooth over time time #the third order exponential smooth the value to smooth over time time  the order the initial value the n'th order exponential smooth the value to smooth over time time  the order the n'th order exponential smooth the value to conserve time the initial value "the first order exponential delay the value to conserve time "the first order exponential delay the value to conserve time the initial value "the third order exponential delay the value to conserve time "the third order exponential delay the value to conserve time  the order the initial value the n'th order exponential delay the value to conserve time  the order the n'th order exponential delay the value to forecast the average time the time horizon  the forecast  ,the value for which the trend is calculated the average time the initial value the fractional change rate !the difference the initial value the sum "#$the value to delay  the lag time the delayed value %the value to delay  the lag time the initial value the delayed value & the stream the discount rate the initial value factor the Net Present Value (NPV) ' the stream the discount rate the initial value factor !the Net Present Value End (NPVE) ( the height the step time )the time start the interval width *the time start the interval width the time period +the slope parameter the time start  the end time #      !"#$%&'()*+#      !"#$%()*+&'&      !"#$%&'()*+  experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred  experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred ,FComputation that generates a new random number distributed uniformly. -NComputation that generates a new random integer number distributed uniformly. .EComputation that generates a new random number distributed normally. /QComputation that returns a new exponential random number with the specified mean  (the reciprocal of the rate). 0MComputation that returns a new Erlang random number with the specified scale 1 (the reciprocal of the rate) and integer shape. 1NComputation that returns a new Poisson random number with the specified mean. 2IComputation that returns a new binomial random number with the specified  probability and trials. 3Computation that returns > in case of success. 4Computation that returns ? in case of success. ,minimum maximum -minimum maximum .mean  deviation /&the mean (the reciprocal of the rate) 0'the scale (the reciprocal of the rate)  the shape 1 the mean 2the probability the number of trials 3the probability of the success 4the probability of the success ,-./01234 ,-./01234 ,-./01234! experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred55Represents an accumulator for the timing statistics. 6#Return the accumulated statistics. 7IStart gathering the timing statistics from the current simulation time. 567567576567" experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred8>It allows representing an analogous circuit as an opposite to  the digital one. DThis is a transform of one time varying function to another usually C specified in the integration time points and then interpolated in A other time points with help of one of the memoization functions  like . :Run the transform. ;4A transform that returns the current modeling time. <HReturn a delayed transform by the specified lag time and initial value. This is actually the % function wrapped in the 8 type. =;Return a transform that maps the derivative to an integral ! by the specified initial value. This is actually the  function wrapped in the 8 type. >5Return a transform that maps the difference to a sum ! by the specified initial value. This is actually the ! function wrapped in the 8 type. 89:;< the lag time the initial value the delayed transform =the initial value "map the derivative to an integral >the initial value map the difference to a sum 89:;<=>89:<;=>89:;<=># experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred?SA transform that memoizes and order the computation in the integration time points N using the interpolation that knows of the Runge-Kutta method. The values are ' calculated sequentially starting from . @ZA transform that memoizes and order the computation in the integration time points using  the 1 interpolation. It consumes less memory than the ? N computation but it is not aware of the Runge-Kutta method. There is a subtle G difference when we request for values in the intermediate time points H that are used by this method to integrate. In general case you should  prefer the @ computation above ?. AQA transform that iterates sequentially the dynamic process with side effects in 6 the integration time points. It is equivalent to the @ computation J but significantly more efficient, for the internal array is not created. ?@A?@A?@A?@A$ experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredB,A transform that returns the initial value. CMA transform that discretizes the computation in the integration time points. DXA tranform that interpolates the computation based on the integration time points only.  Unlike the C. computation it knows about the intermediate 6 time points that are used in the Runge-Kutta method. ELike the standard $ function but applied to values in E the integration time points. The accumulator values are transformed < according to the second argument, which should be either  @ or its unboxed version. FLike the standard $ function but applied to values in E the integration time points. The accumulator values are transformed 9 according to the third argument, which should be either  @ or its unboxed version. BCDEFBCDEFBCDFEBCDEF% experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredGSA transform that memoizes and order the computation in the integration time points N using the interpolation that knows of the Runge-Kutta method. The values are ' calculated sequentially starting from . HZA transform that memoizes and order the computation in the integration time points using  the 1 interpolation. It consumes less memory than the G N computation but it is not aware of the Runge-Kutta method. There is a subtle G difference when we request for values in the intermediate time points H that are used by this method to integrate. In general case you should  prefer the H computation above G. GHGHGHGH experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred& experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred(I/Represents an infinite stream of data in time,  some kind of the cons cell. KRun the stream. L@Create a stream that will use the specified process identifier. - It can be useful to refer to the underlying  computation which B can be passivated, interrupted, canceled and so on. See also the  ; function for more details. M@Memoize the stream so that it would always return the same data  within the simulation run. N1Zip two streams trying to get data sequentially. O8Zip two streams trying to get data as soon as possible, * launching the sub-processes in parallel. P3Zip three streams trying to get data sequentially. Q:Zip three streams trying to get data as soon as possible, * launching the sub-processes in parallel. RUnzip the stream. S8To form each new portion of data for the output stream, 0 read data sequentially from the input streams. This is a generalization of N. T8To form each new portion of data for the output stream, / read data from the input streams in parallel. This is a generalization of O. U>Return a stream of values generated by the specified process. V1Map the stream according the specified function. WCompose the stream. XSequential application. YSequential application. ZGFilter only those data values that satisfy to the specified predicate. [GFilter only those data values that satisfy to the specified predicate. \The stream of  values. ]The stream of  values. ^ Replace the  values. _ Replace the  values. `Partition the stream of  values into two streams. aCSplit the input stream into the specified number of output streams  after applying the - strategy for enqueuing the output requests. bDSplit the input stream into the specified number of output streams.  If you don'5t know what the strategy to apply, then you probably  need the  strategy, or function a that  does namely this. c5Split the input stream into a list of output streams ! using the specified priorities. d+Concatenate the input streams applying the  strategy and  producing one output stream. e;Concatenate the input streams producing one output stream.  If you don'5t know what the strategy to apply, then you probably  need the  strategy, or function d that  does namely this. fDConcatenate the input priority streams producing one output stream. gMerge two streams applying the ( strategy for enqueuing the input data. hMerge two streams.  If you don'5t know what the strategy to apply, then you probably  need the  strategy, or function g that  does namely this. iMerge two priority streams. j)An empty stream that never returns data. kDConsume the stream. It returns a process that infinitely reads data C from the stream and then redirects them to the provided function. G It is useful for modeling the process of enqueueing data in the queue  from the input stream. lASink the stream. It returns a process that infinitely reads data B from the stream. The resulting computation can be a moving force @ to simulate the whole system of the interconnected streams and  processors. mHPrefetch the input stream requesting for one more data item in advance J while the last received item is not yet fully processed in the chain of % streams, usually by the processors. GYou can think of this as the prefetched stream could place its latest H data item in some temporary space for later use, which is very useful B for modeling a sequence of separate and independent work places. n=Return a stream of values triggered by the specified signal. SSince the time at which the values of the stream are requested for may differ from J the time at which the signal is triggered, it can be useful to apply the  P function to add the information about the time points at which the signal was  actually received. The point is that the I! is requested outside, while the  is triggered Z inside. They are different by nature. The former is passive, while the latter is active. WThe resulting stream may be a root of space leak as it uses an internal queue to store X the values received from the signal. The oldest value is dequeued each time we request 7 the stream and it is returned within the computation. Cancel the stream'4s process to unsubscribe from the specified signal. oSReturn a computation of the signal that triggers values from the specified stream, J each time the next value of the stream is received within the underlying   computation. HCancel the returned process to stop reading from the specified stream. pOTransform a stream so that the resulting stream returns a sequence of arrivals R saving the information about the time points at which the original stream items  were received by demand. q@Delay the stream by one step using the specified initial value. ,IJKLMNOPQRSTUVWXYZ[\]^_`ab7the strategy applied for enqueuing the output requests the number of output streams the input stream the splitted output streams c7the strategy applied for enqueuing the output requests the streams of priorities the input stream the splitted output streams de2the strategy applied for enqueuing the input data the input stream the combined output stream f2the strategy applied for enqueuing the input data the input stream the combined output stream gh2the strategy applied for enqueuing the input data the fist input stream the second input stream the output combined stream i2the strategy applied for enqueuing the input data the fist input stream the second input stream the output combined stream jklmnopq)IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq)IJKjghidefabcLmqpMNOPQRSTklUVWXYZ[no\]^_`*IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq' experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferredr+Represents a processor of simulation data. tRun the processor. u6A processor that never finishes its work producing an j. v=Create a simple processor by the specified handling function M that runs the discontinuous process for each input value to get the output. wFAccumulator that outputs a value determined by the supplied function. xCCreate a processor that will use the specified process identifier. - It can be useful to refer to the underlying  computation which B can be passivated, interrupted, canceled and so on. See also the  ; function for more details. yGLaunches the specified processors in parallel consuming the same input 0 stream and producing a combined output stream.  If you don'2t know what the enqueue strategies to apply, then  you will probably need  for the both parameters, or  function } that does namely this. zYLaunches the specified processors in parallel using priorities for combining the output. {YLaunches the specified processors in parallel using priorities for consuming the intput. |MLaunches the specified processors in parallel using priorities for consuming % the input and combining the output. }RLaunches the processors in parallel consuming the same input stream and producing 4 a combined output stream. This version applies the  strategy both for input 6 and output, which suits the most part of uses cases. ~/Launches the processors sequentially using the  between them B to model an autonomous work of each of the processors specified. ECreate a buffer processor, where the process from the first argument K consumes the input stream but the stream passed in as the second argument F and produced usually by some other process is returned as an output. @ This kind of processor is very useful for modeling the queues. Like , but allows creating a loop when some items M can be processed repeatedly. It is very useful for modeling the processors  with queues and loop-backs. >Return a processor with help of which we can model the queue. Although the function doesn'1t refer to the queue directly, its main use case R is namely a processing of the queue. The first argument should be the enqueueing S operation, while the second argument should be the opposite dequeueing operation. NThe reason is as follows. There are many possible combinations how the queues V can be modeled. There is no sense to enumerate all them creating a separate function L for each case. We can just use combinators to define exactly what we need. RSo, the queue can lose the input items if the queue is full, or the input process O can suspend while the queue is full, or we can use priorities for enqueueing, S storing and dequeueing the items in different combinations. There are so many use  cases! PThere is a hope that this function along with other similar functions from this V module is sufficient to cover the most important cases. Even if it is not sufficient * then you can use a more generic function  which this function is U based on. In case of need, you can even write your own function from scratch. It is  quite easy actually. Like < creates a queue processor but with a loop when some items P can be processed and then added to the queue again. Also it allows specifying . how two input streams of data can be merged. Like , creates a queue processor with a loop when V some items can be processed and then added to the queue again. Only it sequentially V merges two input streams of data: one stream that come from the external source and T another stream of data returned by the loop. The first stream has a priority over  the second one. Like , creates a queue processor with a loop when R some items can be processed and then added to the queue again. Only it runs two T simultaneous processes to enqueue the input streams of data: one stream that come K from the external source and another stream of data returned by the loop. HThis is a prefetch processor that requests for one more data item from K the input in advance while the latest item is not yet fully processed in 4 the chain of streams, usually by other processors. JYou can think of this as the prefetched processor could place its latest H data item in some temporary space for later use, which is very useful B for modeling a sequence of separate and independent work places. 7Convert the specified signal transform to a processor. PThe processor may return data with delay as the values are requested by demand.  Consider using the * function to provide with the information C about the time points at which the signal was actually triggered. The point is that the I used in the r is requested outside,  while the 5 is triggered inside. They are different by nature. 4 The former is passive, while the latter is active. Cancel the processor'4s process to unsubscribe from the signals provided. 8Convert the specified processor to a signal transform. PThe processor may return data with delay as the values are requested by demand.  Consider using the * function to provide with the information C about the time points at which the signal was actually triggered. The point is that the I used in the r is requested outside,  while the 4 is triggered inside. They are different by nature. 4 The former is passive, while the latter is active. FCancel the returned process to unsubscribe from the signal specified. FA processor that adds the information about the time points at which 4 the original stream items were received by demand. XA processor that delays the input stream by one step using the specified initial value. rstuvwxy2the strategy applied for enqueuing the input data 3the strategy applied for enqueuing the output data the processors to parallelize the parallelized processor z2the strategy applied for enqueuing the input data 3the strategy applied for enqueuing the output data the processors to parallelize the parallelized processor {2the strategy applied for enqueuing the input data 3the strategy applied for enqueuing the output data 3the streams of input priorities and the processors  to parallelize the parallelized processor |2the strategy applied for enqueuing the input data 3the strategy applied for enqueuing the output data 3the streams of input priorities and the processors  to parallelize the parallelized processor }~)a separate process to consume the input the resulting stream of data .consume two streams: the input values of type a  and the values of type c returned by the loop +the stream of data that may become results ,process and then decide what values of type e 7 should be processed in the loop (this is a condition) ,process in the loop and then return a value  of type c* to the input again (this is a loop body)  enqueue the input item and wait % while the queue is full if required % so that there were no hanging items dequeue an output item the buffering processor ,merge two streams: the input values of type a  and the values of type d returned by the loop  enqueue the input item and wait % while the queue is full if required % so that there were no hanging items +dequeue an item for the further processing ,process and then decide what values of type f 7 should be processed in the loop (this is a condition) ,process in the loop and then return a value  of type d* to the queue again (this is a loop body) the buffering processor  enqueue the input item and wait % while the queue is full if required % so that there were no hanging items +dequeue an item for the further processing ,process and then decide what values of type e 7 should be processed in the loop (this is a condition) ,process in the loop and then return a value  of type a* to the queue again (this is a loop body) the buffering processor  enqueue the input item and wait % while the queue is full if required % so that there were no hanging items +dequeue an item for the further processing ,process and then decide what values of type e 7 should be processed in the loop (this is a condition) ,process in the loop and then return a value  of type a* to the queue again (this is a loop body) the buffering processor rstuvwxyz{|}~rstuvwx~}yz{|rstuvwxyz{|}~( experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredLRepresents the Round-Robbin processor that tries to perform the task within P the specified timeout. If the task times out, then it is canceled and returned S to the processor again; otherwise, the successful result is redirected to output. Like 5 but allows specifying the process identifiers which W must be unique for every new attemp to perform the task even if the task is the same. ) experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred3It models a server that takes a and provides b having state s. !The initial state of the server. !The current state of the server. Provide b by specified a. 3The counted total time spent in awating the input. JThe counted total time spent to process the input and prepare the output. 8The counted total time spent for delivering the output. 9The statistics for the time spent in awaiting the input. OThe statistics for the time spent to process the input and prepare the output. =The statistics for the time spent for delivering the output. AA signal raised when the server recieves a new input to process. 0A signal raised when the input is processed and ) the output is prepared for deliverying. 9A signal raised when the server has supplied the output. ,Create a new server that can provide output b by input a. ? Also it returns the corresponded processor that being applied  updates the server state. ,Create a new server that can provide output b by input a  starting from state s-. Also it returns the corresponded processor . that being applied updates the server state. -Return a processor for the specified server. PThe processor updates the internal state of the server. The usual case is when O the processor is applied only once in a chain of data processing. Otherwise; O every time the processor is used, the state of the server changes. Sometimes P it can be indeed useful if you want to aggregate the statistics for different H servers simultaneously, but it would be more preferable to avoid this. QIf you connect different server processors returned by this function in a chain  with help of ? or other category combinator then this chain will act as one P whole, where the first server will take a new task only after the last server V finishes its current task and requests for the next one from the previous processor = in the chain. This is not always that thing you might need. HTo model a sequence of the server processors working independently, you ' should separate them with help of the  that plays a role + of a small one-place buffer in that case. MThe queue processors usually have the prefetching capabilities per se, where L the items are already stored in the queue. Therefore, the server processor P should not be prefetched if it is connected directly with the queue processor. (Return the current state of the server.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. SReturn the counted total time when the server was locked while awaiting the input. IThe value returned changes discretely and it is usually delayed relative ! to the current simulation time.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. NReturn the counted total time spent by the server while processing the tasks. IThe value returned changes discretely and it is usually delayed relative ! to the current simulation time.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. FReturn the counted total time when the server was locked while trying  to deliver the output. IThe value returned changes discretely and it is usually delayed relative ! to the current simulation time.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. WReturn the statistics of the time when the server was locked while awaiting the input. IThe value returned changes discretely and it is usually delayed relative ! to the current simulation time.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. RReturn the statistics of the time spent by the server while processing the tasks. IThe value returned changes discretely and it is usually delayed relative ! to the current simulation time.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. JReturn the statistics of the time when the server was locked while trying  to deliver the output. IThe value returned changes discretely and it is usually delayed relative ! to the current simulation time.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. FIt returns the factor changing from 0 to 1, which estimates how often 2 the server was awaiting for the next input task. This factor is calculated as    totalInputWaitTime /B (totalInputWaitTime + totalProcessingTime + totalOutputWaitTime) DAs before in this module, the value returned changes discretely and @ it is usually delayed relative to the current simulation time.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. FIt returns the factor changing from 0 to 1, which estimates how often 7 the server was busy with direct processing its tasks. This factor is calculated as    totalProcessingTime /B (totalInputWaitTime + totalProcessingTime + totalOutputWaitTime) DAs before in this module, the value returned changes discretely and @ it is usually delayed relative to the current simulation time.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. FIt returns the factor changing from 0 to 1, which estimates how often P the server was locked trying to deliver the output after the task is finished. This factor is calculated as    totalOutputWaitTime /B (totalInputWaitTime + totalProcessingTime + totalOutputWaitTime) DAs before in this module, the value returned changes discretely and @ it is usually delayed relative to the current simulation time.  See also  and . Signal when the  property value has changed. Signal when the  property value has changed. 2Raised when the server receives a new input task. 4Raised when the server has just processed the task. 6Raised when the server has just delivered the output. 4Signal whenever any property of the server changes. 9Return the summary for the server with desciption of its 7 properties and activities using the specified indent. 4)provide an output by the specified input 1provide a new state and output by the specified  old state and input the initial state ()' * experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred8Represents a circuit synchronized with the event queue. > Besides, it allows creating the recursive links with help of  the proc-notation. Run the circuit. 1Get a signal transform by the specified circuit. &Transform the circuit to a processor. ;Create a simple circuit by the specified handling function B that runs the computation for each input value to get an output. FAccumulator that outputs a value determined by the supplied function. DA circuit that adds the information about the time points at which  the values were received. ?Delay the input by one step using the specified initial value. 2A circuit that returns the current modeling time. Like , but processes only the represented events. Like , but processes only the represented events. MFilter the circuit, calculating only those parts of the circuit that satisfy  the specified predicate. Filter the circuit within the + computation, calculating only those parts 6 of the circuit that satisfy the specified predicate. 'The source of events that never occur. ,An approximation of the integral using Euler' s method. 8This function can be rather inaccurate as it depends on  the time points at wich the  computation is actuated.  Also Euler'6s method per se is not most accurate, although simple  enough for implementation. Consider using the  function whenever possible. D That function can integrate with help of the Runge-Kutta method by I the specified integration time points that are passed in the simulation  specs to every , when running the model. At the same time, the  function has no mutable state D unlike the former. The latter consumes less memory but at the cost E of inaccuracy and relatively more slow simulation, had we requested ' the integral in the same time points. JRegarding the recursive equations, the both functions allow defining them G but whithin different computations (either with help of the recursive $ do-notation or the proc-notation). @A sum of differences starting from the specified initial value. !Consider using the more accurate ! function whener possible as E it is calculated in every integration time point specified by specs  passed in to every , when running the model. At the same time, the # function has no mutable state and * it consumes less memory than the former. JRegarding the recursive equations, the both functions allow defining them G but whithin different computations (either with help of the recursive $ do-notation or the proc-notation). AApproximate the circuit as a transform of time varying function, @ calculating the values in the integration time points and then A interpolating in all other time points. The resulting transform < computation is synchronized with the event queue. GThis procedure consumes memory as the underlying memoization allocates * an array to store the calculated values. whether there is an event !process the event if it presents Athe resulting circuit that processes only the represented events !process the event if it presents whether there is an event Athe resulting circuit that processes only the represented events the initial value "map the derivative to an integral the initial value map the difference to a sum + experimental (David Sorokin <david.sorokin@gmail.com>  Safe-Inferred 6Represents the net as an automaton working within the  computation.  Run the net. $A net that never finishes its work. 7Create a simple net by the specified handling function L that runs the discontinuous process for each input value to get an output. FAccumulator that outputs a value determined by the supplied function. =Create a net that will use the specified process identifier. - It can be useful to refer to the underlying  computation which B can be passivated, interrupted, canceled and so on. See also the  ; function for more details. NTransform the net to an equivalent processor (a rather cheap transformation). ITransform the processor to a similar net (a more costly transformation). @A net that adds the information about the time points at which  the values were received. ?Delay the input by one step using the specified initial value.     experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredQAccumulates the statistics about that how long the arrived events are processed. LCreate a new timer that measures how long the arrived events are processed. MReturn the statistics about that how long the arrived events were processed. HReturn a signal raised when the the processing time statistics changes. HReturn a signal raised when the the processing time statistics changes. HReturn a processor that actually measures how much time has passed from " the time of arriving the events.   , experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredJThe result entity identifier. %A localised property or object name. An user defined description.  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Represents a .  Property . An .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property .  Property s.  Property .  Property .  Property v.  Property u.  Property t.  An infinite .  A finite r.  Property <.  Property ;.  Property :.  Property 9.  Property 8.  Property 7.  Property O.  Property 1.   Property 0.   Property 6.   Property 5.   Property 4.  A 2 value.  Property J.  Property I.  Property G.  Property F.  Property E.  Property D.  Property C. A A value. 6Describes a vector item with the specified subscript. Describes a vector. A  computation. FA description used for describing the results when generating output. 4It localises the description of simulation results. +A locale to output the simulation results. Examples are: "ru", "en" etc. The Russian locale. The English locale. 4The Russian localisation of the simulation results. 4The English localisation of the simulation results.  /Lookup a localisation by the specified locale. J      J      J       A      - experimental'David Sorokin <david.sorokin@gmail.com>None!2Represents a vector with the specified subscript. #2Represents an array with the specified subscript. %0Represents a list with the specified subscript. '>Represents a computation that can return the simulation data. )"Return data from the computation. *&Return a signal from the computation. +>Represents a computation that can return the simulation data. ,-Compute data with the results of simulation. -FReturn the signal triggered when data change if such a signal exists. .ADefines a final result extract: its name, values and other data. 0The result name. 1The result identifier. 2The result values. 3#Whether the result emits a signal. 4JIt representes the predefined signals provided by every simulation model. 65The signal triggered in the integration time points. 7(The signal triggered in the start time. 8'The signal triggered in the stop time. 9)It transforms the results of simulation. :'It contains the results of simulation. ;@The sources of simulation results as a map of associated names. <6The sources of simulation results as an ordered list. =XWhether an object containing the results emits a signal notifying about change of data. ><When the specified signal was combined with unknown signal. ?(When the signal is precisely specified. @8The signal is unknown, but the entity probably changes. AThere is no signal at all. B(Represents the very simulation results. CFA container of the simulation results such as queue, server or array. EThe container name. FThe container identifier. GThe container data. HDWhether the container emits a signal when changing simulation data. IgA parameterised value that actually represents a generalised result item that have no parametric type. KThe value name. LThe value identifier. M'Simulation data supplied by the value. N@Whether the value emits a signal when changing simulation data. O3It separates the simulation results when printing. QThe separator text. R0The simulation results represented by a vector. TThe vector name. UThe vector identifier. V*The results supplied by the vector items. W5The subscript used as a suffix to create item names. XA combined signal if present. Y-A short version of the vector, i.e. summary. Z7The object property containing the simulation results. \The property short label. ]The property identifier. ^1The simulation results supplied by the property. _CThe simulation results represented by an object having properties. aThe object name. bThe object identifier. cThe object type identifier. dThe object properties. eA combined signal if present. f1A short version of the object, i.e. its summary. g;Represents a type class for actual representing the items. hThe item name. iThe item identifier. j!Whether the item emits a signal. k5Return an expanded version of the item, for example, 2 when the statistics item is exanded to an object 8 having the corresponded properties for count, average, ( deviation, minimum, maximum and so on. l>Return usually a short version of the item, i.e. its summary, 9 but values of some data types such as statistics can be 8 implicitly expanded to an object with the corresponded  properties. m'Return integer numbers in time points. n1Return lists of integer numbers in time points. o,Return statistics based on integer numbers. p3Return timing statistics based on integer numbers. q&Return double numbers in time points. r0Return lists of double numbers in time points. s+Return statistics based on double numbers. t3Return timing statistics based on integer numbers. u.Return string representations in time points. v5The simulation results represented by a single item. x Encapsulates the result source. yThis is a separator text. zA vector-like structure. {An object-like source. |(The source consisting of a single item. }3It associates the result sources with their names. ~MRepresents a provider of the simulation results. It is usually something, or U an array of something, or a list of such values which can be simulated to get data. ZReturn the source of simulation results by the specified name, description and provider. YReturn the source of simulation results by the specified name, identifier and provider. AA name used for indentifying the results when generating output. \Return a version optimised for fast aggregation of the statistics based on integer numbers. jReturn a version optimised for fast aggregation of the statistics based on double floating point numbers. CCalculate the result vector signal and memoize it in a new vector. DCalculate the result vector summary and memoize it in a new vector. :Return a new value with the discarded simulation results. 9Create a new property source by the specified container. 7Create a constant property by the specified container. |Create by the specified container a property that changes in the integration time points, or it is supposed to be such one. .Create a property by the specified container. cCreate by the specified container a mapped property which is recomputed each time again and again. OConvert the result value to a container with the specified object identifier. )Convert the result container to a value. EConstruct a new result signal by the specified optional pure signal. Flatten the result source. Return the result source name. aExpand the result source returning a more detailed version expanding the properties as possible. Return a summarised and usually more short version of the result source expanding the main properties or excluding auxiliary properties if required. 'Return a signal emitted by the source. 0Represent the result source as integer numbers. 9Represent the result source as lists of integer numbers. DRepresent the result source as statistics based on integer numbers. gRepresent the result source as statistics based on integer numbers and optimised for fast aggregation. KRepresent the result source as timing statistics based on integer numbers. >Represent the result source as double floating point numbers. GRepresent the result source as lists of double floating point numbers. RRepresent the result source as statistics based on double floating point numbers. uRepresent the result source as statistics based on double floating point numbers and optimised for fast aggregation. YRepresent the result source as timing statistics based on double floating point numbers. .Represent the result source as string values. BCreate the predefined signals provided by every simulation model.  Prepare the simulation results. *Represent the results as integer numbers. 3Represent the results as lists of integer numbers. >Represent the results as statistics based on integer numbers. aRepresent the results as statistics based on integer numbers and optimised for fast aggregation. ERepresent the results as timing statistics based on integer numbers. 8Represent the results as double floating point numbers. ARepresent the results as lists of double floating point numbers. LRepresent the results as statistics based on double floating point numbers. oRepresent the results as statistics based on double floating point numbers and optimised for fast aggregation. SRepresent the results as timing statistics based on double floating point numbers. (Represent the results as string values. 2Return a signal emitted by the specified results. aReturn an expanded version of the simulation results expanding the properties as possible, which c takes place for expanding statistics to show the count, average, deviation, minimum, maximum etc.  as separate values. dReturn a short version of the simulation results, i.e. their summary, expanding the main properties 0 or excluding auxiliary properties if required. Take a result by its name. ATake a result from the object with the specified property label, < but it is more preferrable to refer to the property by its   identifier with help of the  function. MTake a result from the object with the specified identifier. It can identify E an item, object property, the object iself, vector or its elements. >Take a result from the vector by the specified integer index. ATake a result from the vector by the specified string subscript. ACompose the results using the specified transformation function. NConcatenate the results using the specified list of transformation functions. AAppend the results using the specified transformation functions. JReturn a pure signal as a result of combination of the predefined signals C with the specified result signal usually provided by the sources. FThe signal returned is triggered when the source signal is triggered. B The pure signal is also triggered in the integration time points M if the source signal is unknown or it was combined with any unknown signal. DExtract the results as integer values, or raise a conversion error. MExtract the results as lists of integer values, or raise a conversion error. ;Extract the results as statistics based on integer values,  or raise a conversion error. HExtract the results as statistics based on integer values and optimised 4 for fast aggregation, or raise a conversion error. BExtract the results as timing statistics based on integer values,  or raise a conversion error. RExtract the results as double floating point values, or raise a conversion error. >Extract the results as lists of double floating point values,  or raise a conversion error. IExtract the results as statistics based on double floating point values,  or raise a conversion error. HExtract the results as statistics based on double floating point values B and optimised for fast aggregation, or raise a conversion error. PExtract the results as timing statistics based on double floating point values,  or raise a conversion error. CExtract the results as string values, or raise a conversion error. MReturn a new result value by the specified name, identifier and computation. -Return a source by the specified statistics. 0Return the summary by the specified statistics. 4Return a source by the specified timing statistics. 7Return the summary by the specified timing statistics. /Return a source by the specified finite queue. 2Return the summary by the specified finite queue. 1Return a source by the specified infinite queue. 4Return the summary by the specified infinite queue. 0Return a source by the specified arrival timer. 3Return the summary by the specified arrival timer. )Return a source by the specified server. ,Return the summary by the specified server. 0Return an arbitrary text as a separator source. (Return the source of the modeling time. Make an integer subscript !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~the container the property label the property identifier *get the specified data from the container 'get the data signal from the container the container the property label the property identifier *get the specified data from the container the container the property label the property identifier *get the specified data from the container the container the property label the property identifier *get the specified data from the container +get a signal triggered when changing data. the container the property label the property identifier recompute the specified data the result name the result identifier the result computation the statistics the statistics the statistics the statistics the queue container the queue container the queue container the queue container the arrival timer container the arrival timer container the server container the server container !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~:;<9~+,-'()*%&#$!"./012345678}x|{zyvwghijklmnopqrstu_`abcdefZ[\]^RSTUVWXYOPQIJKLMNCDEFGHB=A@?>;<!"#$%&'()*+,-./0123456789:;<=A@?>BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx|{zy}~. experimental (David Sorokin <david.sorokin@gmail.com> None&=This is a function that prints the simulation results within  the 0 computation synchronized with the event queue. <This is a function that shows the simulation results within  the 0 computation synchronized with the event queue. MPrint a localised text representation of the results by the specified source  and with the given indent. EPrint an indented and labelled text representation of the results by  the specified source. MPrint a localised text representation of the results by the specified source  and with the given indent. NPrint a localised text representation of the results by the specified source. NPrint a localised text representation of the results by the specified source. OPrint in Russian a text representation of the results by the specified source. OPrint in English a text representation of the results by the specified source. OPrint in Russian a text representation of the results by the specified source. OPrint in English a text representation of the results by the specified source. LShow a localised text representation of the results by the specified source  and with the given indent. ZShow an indented and labelled text representation of the results by the specified source. MShow a localised text representation of the results by the specified source. NShow in Russian a text representation of the results by the specified source. NShow in English a text representation of the results by the specified source. @Print the results with the information about the modeling time. ,Print the simulation results in start time. +Print the simulation results in stop time. =Print the simulation results in the integration time points. 4Print the simulation results in the specified time. ;Print the simulation results in the specified time points. ?Show the results with the information about the modeling time. +Show the simulation results in start time. *Show the simulation results in stop time. <Show the simulation results in the integration time points. HIt may consume much memory, for we have to traverse all the integration 4 points to create the resulting function within the  computation. 9Show the simulation results in the specified time point. :Show the simulation results in the specified time points. FIt may consume much memory, for we have to traverse all the specified 4 points to create the resulting function within the  computation. ARun the simulation and then print the results in the start time. ARun the simulation and then print the results in the final time. NRun the simulation and then print the results in the integration time points. KRun the simulation and then print the results in the specified time point. LRun the simulation and then print the results in the specified time points. @Run the simulation and then show the results in the start time. @Run the simulation and then show the results in the final time. MRun the simulation and then show the results in the integration time points. HIt may consume much memory, for we have to traverse all the integration 4 points to create the resulting function within the  computation. LRun the simulation and then show the results in the integration time point. KRun the simulation and then show the results in the specified time points. FIt may consume much memory, for we have to traverse all the specified 4 points to create the resulting function within the  computation. & a handle  an indent a localisation  a handle  an indent a label a localisation  an indent a localisation  a handle a localisation a localisation  an indent a localisation  an indent a label a localisation a localisation $$&/ experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredFReturn a sream of random events that arrive with the specified delay. 7Create a new stream with delays distributed uniformly. ?Create a new stream with integer delays distributed uniformly. 6Create a new stream with delays distributed normally. QReturn a new stream with delays distibuted exponentially with the specified mean  (the reciprocal of the rate). RReturn a new stream with delays having the Erlang distribution with the specified : scale (the reciprocal of the rate) and shape parameters. EReturn a new stream with delays having the Poisson distribution with  the specified mean. TReturn a new stream with delays having the binomial distribution with the specified  probability and trials. .compute a pair of the delay and event of type a a stream of delayed events the minimum delay the maximum delay 6the stream of random events with the delays generated the minimum delay the maximum delay 6the stream of random events with the delays generated the mean delay the delay deviation 6the stream of random events with the delays generated ,the mean delay (the reciprocal of the rate) 6the stream of random events with the delays generated 'the scale (the reciprocal of the rate)  the shape 6the stream of random events with the delays generated the mean delay 6the stream of random events with the delays generated the probability the number of trials 6the stream of random events with the delays generated 0 experimental (David Sorokin <david.sorokin@gmail.com>  Safe-InferredRepresents the agent state. Return the corresponded agent. Return the parent state or !. Represents an agent. :Add to the state a timeout handler that will be actuated ? in the specified time period if the state will remain active. 7Add to the state a timer handler that will be actuated B in the specified time period and then repeated again many times, ! while the state remains active. Create a new state. Create a child state. Create an agent. "Return the selected active state. BSelect the state. The activation and selection are repeated while * there is the transition state defined by . 8Set the activation computation for the specified state. :Set the deactivation computation for the specified state. CSet the transition state which will be next and which is used only 0 when selecting the state directly with help of . ; If the state was activated intermediately, when selecting 3 another state, then this computation is not used. 1Trigger the signal when the agent state changes. HReturn a signal that notifies about every change of the selected state. HReturn a signal that notifies about every change of the selected state. $    : experimental (David Sorokin <david.sorokin@gmail.com> None-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq,-./0123456789:;<=>BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ;<=>?@ABCDEFGHIJKLMNOPQ=>?@ABCDEFGHRSTUVWXYZ[\]^_`aabcdefghijklmnoopqrstuvwxyz{|}~1111111111111111111222222222222222223333333334444444444444445555555555555555555555555555556666677777777777777 7 7 7 7 77777777777777777 !"#$%&'()!"#$%&'()8*8+8,8-8.8/909192939495969798999:9;9<9=9>9?9@9A9B9C9D9E9F9G9H9I9J9K9L9M9N9O9P9Q9R9S9T9U9V9W9X9Y9Z9[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ILJKNMILJKNM         !!!"""""""###$$$$$ %%&!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&A&B&C&D&E&F&G&H&I'J'J'K'L'M'N'O'P'Q'R'S'T'U'V'W'X'Y'Z'['\']'^'_'`(a(b)c)d)e)f)g)h)i)j)k)l)m)n)o)p)q)r)s)t)u)v)w)x)y)z){)|)})~))))))))))))******************+++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,-------------------------- - - - - - ----------------------- -!-"-#-$-$-%-&-'-(-(-)-*-+-,---.-/-0-1-2-3-4-5-6-7-8-9-:-;-<-=->->-?-@-A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^-_-`-a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z-{-|-}-~-------....................................////////0000000000000000=I=R1111111111 1 1 1 1 111111111111 222222 2!2"2#2$2%2&2'2(2)2*2+3,3-33.3/3031323334353637384944:4;4<4=4>4?4@4A4B4C4D4E4F4G4H4I4J4K4L5M5N5O5P5Q5R5S5T5U555V5W5X515Y5?5Z5[5\5]5^5_5`5a5b5cdefghijklmnopqrs7t7u7v7w7x7y77z7{7t7|7}7u7~777777f!!888888888888888888888888888888888888888888*888888888888888899999999929399999999999>999999999999\y     !!"""&&&'''''))) )!)")#)$)%)&)')()*)c)+*,*-*.*/+0+1+234-5-6-7-8-9-:-;-<-=->-?-@-A-B-C-D-E-F-G-H- -I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^-_-`-a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z-{.|.}0~0000000000000000000 aivika-2.0Simulation.Aivika.TableSimulation.Aivika.VectorSimulation.Aivika.PriorityQueueSimulation.Aivika.Unboxed Simulation.Aivika.Vector.Unboxed"Simulation.Aivika.DoubleLinkedListSimulation.Aivika.StatisticsSimulation.Aivika.GeneratorSimulation.Aivika.SpecsSimulation.Aivika.ParameterSimulation.Aivika.SimulationSimulation.Aivika.DynamicsSimulation.Aivika.EventSimulation.Aivika.Ref.PlainSimulation.Aivika.QueueStrategySimulation.Aivika.ArrivalSimulation.Aivika.SignalSimulation.Aivika.RefSimulation.Aivika.VarSimulation.Aivika.Var.UnboxedSimulation.Aivika.ContSimulation.Aivika.ProcessSimulation.Aivika.ResourceSimulation.Aivika.TaskSimulation.Aivika.Queue Simulation.Aivika.Queue.Infinite Simulation.Aivika.Dynamics.ExtraSimulation.Aivika.Dynamics.Memo'Simulation.Aivika.Dynamics.Memo.Unboxed!Simulation.Aivika.Dynamics.Random Simulation.Aivika.SystemDynamics"Simulation.Aivika.Parameter.Random(Simulation.Aivika.Statistics.AccumulatorSimulation.Aivika.Transform Simulation.Aivika.Transform.Memo!Simulation.Aivika.Transform.Extra(Simulation.Aivika.Transform.Memo.UnboxedSimulation.Aivika.StreamSimulation.Aivika.Processor'Simulation.Aivika.Processor.RoundRobbinSimulation.Aivika.ServerSimulation.Aivika.CircuitSimulation.Aivika.Net Simulation.Aivika.Results.LocaleSimulation.Aivika.ResultsSimulation.Aivika.Results.IOSimulation.Aivika.Stream.RandomSimulation.Aivika.Agent Simulation.Aivika.Internal.Specs$Simulation.Aivika.Internal.Parameter%Simulation.Aivika.Internal.Simulation#Simulation.Aivika.Internal.Dynamics Simulation.Aivika.Internal.Event"Simulation.Aivika.Internal.Arrival!Simulation.Aivika.Internal.SignalSimulation.Aivika.Internal.Cont"Simulation.Aivika.Internal.ProcessSimulation.Aivika tableLookuptableLookupStepwiseVector newVector copyVector vectorCount appendVector readVector writeVectorvectorBinarySearch freezeVector vectorInsertvectorDeleteAt vectorIndex PriorityQueue queueNull queueCountnewQueueenqueuedequeue queueFrontUnboxednewUnboxedArray_DoubleLinkedListlistNull listCountnewListlistInsertFirst listAddLastlistRemoveFirstlistRemoveLast listFirstlistLast TimingDataemptyTimingStatsaddTimingStatstimingStatsMeantimingStatsVariance TimingStatstimingStatsCounttimingStatsMintimingStatsMaxtimingStatsMinTimetimingStatsMaxTimetimingStatsStartTimetimingStatsLastTimetimingStatsSumtimingStatsSum2 SamplingDataemptySamplingStatsaddSamplingStatscombineSamplingStats SamplingStatssamplingStatsCountsamplingStatsMinsamplingStatsMaxsamplingStatsMeansamplingStatsMean2combineSamplingStatsEithersamplingStatsVariancesamplingStatsDeviationreturnSamplingStatslistSamplingStatsfromIntSamplingStatssamplingStatsSummarytimingStatsDeviationreturnTimingStatsfromIntTimingStatstimingStatsSummary GeneratorTypeCustomGenerator01CustomGeneratorSimpleGeneratorWithSeedSimpleGenerator GeneratorgenerateUniformgenerateUniformIntgenerateNormalgenerateExponentialgenerateErlanggeneratePoissongenerateBinomial newGeneratornewRandomGeneratorMethod RungeKutta4 RungeKutta2EulerSpecs spcStartTime spcStopTimespcDT spcMethodspcGeneratorTypeintegIterationBndsintegIterationLoBndintegIterationHiBndintegPhaseBndsintegPhaseLoBndintegPhaseHiBnd basicTime integTimes ParameterLift liftParameter Parameter runParameter runParameterssimulationIndexsimulationCountsimulationSpecsgeneratorParametercatchParameterfinallyParameterthrowParameter memoParametertableParameter starttimestoptimedtSimulationLiftliftSimulation Simulation runSimulationrunSimulationscatchSimulationfinallySimulationthrowSimulationmemoSimulation DynamicsLift liftDynamicsDynamicsrunDynamicsInStartTimerunDynamicsInStopTimerunDynamicsInIntegTimesrunDynamicsInTimerunDynamicsInTimes catchDynamicsfinallyDynamics throwDynamicstime isTimeIntegintegIteration integPhaseDisposableEvent disposeEventEventCancellation cancelEventeventCancelled eventFinishedEventProcessingEarlierEventsOrFromPastCurrentEventsOrFromPast EarlierEvents CurrentEvents EventLift liftEventEvent catchEvent finallyEvent throwEvent enqueueEventrunEvent runEventWithrunEventInStartTimerunEventInStopTimeeventQueueCountenqueueEventWithTimesenqueueEventWithIntegTimesenqueueEventWithCancellation memoEventmemoEventInTime yieldEventRefnewRefreadRefwriteRef modifyRefStaticPrioritiesSIROLCFSFCFSPriorityQueueStrategystrategyEnqueueWithPriorityEnqueueStrategystrategyEnqueueDequeueStrategystrategyDequeue QueueStrategy StrategyQueuenewStrategyQueuestrategyQueueNullArrival arrivalValue arrivalTime arrivalDelay SignalablereadSignalablesignalableChanged_ SignalHistorysignalHistorySignalSignal handleSignal SignalSource publishSignal triggerSignal handleSignal_newSignalSource mapSignal filterSignal filterSignalM merge2Signals merge3Signals merge4Signals merge5Signals mapSignalMapSignal emptySignalnewSignalHistorynewSignalHistoryStartingWithreadSignalHistorynewSignalInTimesnewSignalInIntegTimesnewSignalInStartTimenewSignalInStopTimesignalableChangedemptySignalableappendSignalable arrivalSignal refChanged refChanged_VarnewVarvarMemoreadVarwriteVar modifyVar freezeVar varChanged varChanged_ContContCancellationCancelInIsolationCancelParentAfterChildCancelChildAfterParentCancelTogether ProcessLift liftProcessProcess ProcessId holdProcessinterruptProcessprocessInterruptedpassivateProcessprocessPassivereactivateProcess runProcessrunProcessUsingIdrunProcessInStartTimerunProcessInStartTimeUsingIdrunProcessInStopTimerunProcessInStopTimeUsingIdenqueueProcessenqueueProcessUsingId processId newProcessIdcancelProcessWithId cancelProcessprocessCancelledprocessCancellingwhenCancellingProcess catchProcessfinallyProcess throwProcessprocessParallelprocessParallelUsingIdsprocessParallel_processParallelUsingIds_processUsingId spawnProcessspawnProcessUsingId processAwait memoProcesszipProcessParallelzip3ProcessParallel unzipProcesstimeoutProcesstimeoutProcessUsingId processYield neverProcessResourceresourceStrategyresourceMaxCountPriorityResource SIROResource LCFSResource FCFSResourcenewFCFSResourcenewFCFSResourceWithMaxCountnewLCFSResourcenewLCFSResourceWithMaxCountnewSIROResourcenewSIROResourceWithMaxCountnewPriorityResourcenewPriorityResourceWithMaxCount newResourcenewResourceWithMaxCount resourceCountrequestResourcerequestResourceWithPriorityreleaseResourcereleaseResourceWithinEventtryRequestResourceWithinEvent usingResourceusingResourceWithPriority TaskResult TaskCancelled TaskError TaskCompletedTasktaskIdtaskResultReceivedtryGetTaskResult taskResult cancelTask taskCancelledrunTaskUsingIdrunTaskenqueueTaskUsingId enqueueTaskspawnTaskUsingId spawnTask taskProcessQueue queueMaxCountenqueueStrategyenqueueStoringStrategydequeueStrategy SIROQueue LCFSQueue FCFSQueue newFCFSQueue newLCFSQueue newSIROQueuenewPriorityQueuequeueNullChangedqueueNullChanged_ queueFullqueueFullChangedqueueFullChanged_queueCountStatsqueueCountChangedqueueCountChanged_ enqueueCountenqueueCountChangedenqueueCountChanged_enqueueLostCountenqueueLostCountChangedenqueueLostCountChanged_enqueueStoreCountenqueueStoreCountChangedenqueueStoreCountChanged_ dequeueCountdequeueCountChangeddequeueCountChanged_dequeueExtractCountdequeueExtractCountChangeddequeueExtractCountChanged_queueLoadFactorqueueLoadFactorChangedqueueLoadFactorChanged_ enqueueRateenqueueStoreRate dequeueRatedequeueExtractRate queueWaitTimequeueWaitTimeChangedqueueWaitTimeChanged_queueTotalWaitTimequeueTotalWaitTimeChangedqueueTotalWaitTimeChanged_enqueueWaitTimeenqueueWaitTimeChangedenqueueWaitTimeChanged_dequeueWaitTimedequeueWaitTimeChangeddequeueWaitTimeChanged_ queueRatequeueRateChangedqueueRateChanged_dequeueWithOutputPriority tryDequeueenqueueWithInputPriorityenqueueWithStoringPriority!enqueueWithInputStoringPriorities tryEnqueuetryEnqueueWithStoringPriority enqueueOrLost enqueueWithStoringPriorityOrLostenqueueOrLost_!enqueueWithStoringPriorityOrLost_enqueueInitiated enqueueStored enqueueLostdequeueRequesteddequeueExtractedwaitWhileFullQueue queueChanged_ queueSummary initDynamicsdiscreteDynamicsinterpolateDynamics scan1Dynamics scanDynamics memoDynamics memo0DynamicsiterateDynamics unzipDynamicsunzip0DynamicsmemoRandomUniformDynamicsmemoRandomUniformIntDynamicsmemoRandomNormalDynamicsmemoRandomExponentialDynamicsmemoRandomErlangDynamicsmemoRandomPoissonDynamicsmemoRandomBinomialDynamics.==../=..<..>=..>..<=. maxDynamics minDynamics ifDynamicsintegsmoothIsmoothsmooth3Ismooth3smoothNIsmoothNdelay1Idelay1delay3Idelay3delayNIdelayNforecasttrenddiffsumlookupDynamicslookupStepwiseDynamicsdelaydelayInpvnpvesteppulsepulsePramp randomUniformrandomUniformInt randomNormalrandomExponential randomErlang randomPoissonrandomBinomial randomTrue randomFalseTimingStatsAccumulatortimingStatsAccumulatednewTimingStatsAccumulator Transform runTransform timeTransformdelayTransformintegTransform sumTransform memoTransformmemo0TransformiteratingTransform initTransformdiscreteTransforminterpolatingTransformscan1Transform scanTransformStreamCons runStream streamUsingId memoStream zipStreamSeqzipStreamParallel zip3StreamSeqzip3StreamParallel unzipStream streamSeqstreamParallel repeatProcess mapStream mapStreamMapStream apStreamM filterStream filterStreamM leftStream rightStreamreplaceLeftStreamreplaceRightStreampartitionEitherStream splitStreamsplitStreamQueueingsplitStreamPrioritising concatStreamsconcatQueuedStreamsconcatPriorityStreams mergeStreamsmergeQueuedStreamsmergePriorityStreams emptyStream consumeStream sinkStreamprefetchStream signalStream streamSignal arrivalStream delayStream Processor runProcessoremptyProcessor arrProcessoraccumProcessorprocessorUsingIdprocessorQueuedParallel#processorPrioritisingOutputParallel"processorPrioritisingInputParallel(processorPrioritisingInputOutputParallelprocessorParallel processorSeqbufferProcessorbufferProcessorLoopqueueProcessorqueueProcessorLoopMergingqueueProcessorLoopSeqqueueProcessorLoopParallelprefetchProcessorsignalProcessorprocessorSignalingarrivalProcessordelayProcessorroundRobbinProcessorroundRobbinProcessorUsingIdsServerserverInitState newServernewStateServerserverProcessor serverStateserverStateChangedserverStateChanged_serverTotalInputWaitTimeserverTotalInputWaitTimeChanged serverTotalInputWaitTimeChanged_serverTotalProcessingTime serverTotalProcessingTimeChanged!serverTotalProcessingTimeChanged_serverTotalOutputWaitTime serverTotalOutputWaitTimeChanged!serverTotalOutputWaitTimeChanged_serverInputWaitTimeserverInputWaitTimeChangedserverInputWaitTimeChanged_serverProcessingTimeserverProcessingTimeChangedserverProcessingTimeChanged_serverOutputWaitTimeserverOutputWaitTimeChangedserverOutputWaitTimeChanged_serverInputWaitFactorserverInputWaitFactorChangedserverInputWaitFactorChanged_serverProcessingFactorserverProcessingFactorChangedserverProcessingFactorChanged_serverOutputWaitFactorserverOutputWaitFactorChangedserverOutputWaitFactorChanged_serverInputReceivedserverTaskProcessedserverOutputProvidedserverChanged_ serverSummaryCircuit runCircuitcircuitSignalingcircuitProcessor arrCircuit accumCircuitarrivalCircuit delayCircuit timeCircuit>?>>><<<$fArrowChoiceCircuit$fArrowLoopCircuit$fArrowCircuit$fCategoryCircuit$fArrowChoiceNet $fArrowNet $fCategoryNetarrivalProcessingTimeRef"arrivalProcessingTimeChangedSourceflattenResultSourceresultSourceNameexpandResultSourceresultSourceSummaryresultSourceSignal concatResults appendResultssamplingStatsResultSourcesamplingStatsResultSummarytimingStatsResultSourcetimingStatsResultSummaryqueueResultSourcequeueResultSummaryinfiniteQueueResultSourceinfiniteQueueResultSummaryarrivalTimerResultSourcearrivalTimerResultSummaryserverResultSourceserverResultSummary intSubscript$fResultProviderServer$fResultProviderArrivalTimer$fResultProviderQueue$fResultProviderQueue0$fResultProviderm$fResultProviderm0$fResultProviderm1$fResultProviderm2)$fResultProviderResultVectorWithSubscript($fResultProviderResultArrayWithSubscript'$fResultProviderResultListWithSubscript$fResultProviderVector$fResultProviderArray$fResultProvider[]$fResultProviderm3$fResultProviderm4$fResultProviderm5$fResultProviderm6$fResultProviderm7$fResultProviderm8$fResultProviderm9$fResultProviderm10$fResultProviderm11$fResultComputingSignalable$fResultComputingVar$fResultComputingRef$fResultComputingRef0$fResultComputingEvent$fResultComputingDynamics$fResultComputingSimulation$fResultComputingParameter"$fResultComputingResultComputation$fMonoidResults$fResultItemableResultValue$fResultItemableResultValue0$fResultItemableResultValue1$fResultItemableResultValue2$fResultItemableResultValue3$fResultItemableResultValue4$fResultItemableResultValue5$fResultItemableResultValue6$fResultItemableResultValue7$fResultItemableResultValue8$fResultItemableResultValue9$fResultItemableResultValue10$fResultItemableResultValue11$fResultItemableResultValue12$fResultItemableResultValue13$fMonoidResultSignal$fFunctorResultContainer$fFunctorResultValue"hPrintResultSourceIndentedLabelled showResultSourceIndentedLabelledtriggerAgentStateChanged AgentModeProcessingMode TransientMode CreationModestateActivateRefstateDeactivateRefstateTransitRefstateVersionRef agentModeRef agentStateRefagentStateChangedSourcefullPath partitionPathfindPath traversePath$fEqAgentState $fEqAgent