q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./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,{,|,},~,-------------../////////////////////////////////////////////////////0000000000000000000000000011111111111111111111111111111222222222222222 2 3 3 3 3333333333444 4!4"4#4$4%4&4'4(4)4*4+5,5-5.5/505152535455565758595:5;6<6=6>6?6@6A6B6C6D6E6F6G6H6I6J6K6L6M6N6O6P6Q6R6S6T6U6V6W6X6Y6Z6[6\6]6^6_6`6a6b6c6d6e6f7g7h7i7j7k7l7m7n7o7p7q7r7s7t7u7v7w7x7y7z7{7|7}7~7788888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888999999999999999999999999999999999 9 9 9 9 9999999999999999999 9!9"9#9$9%9&9'9(9)9*9+9,9-9.9/909192939495969798999:9;9<9=9>9?9@9A9B9C9D9E9F9G9H9I9J9K9L9M9N9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9\9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}9~9::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;D@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental 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.@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-Inferred3Represents a resizable vector.Create a new vector.Copy the vector.2Ensure that the vector has the specified capacity.Return the element count.3Add the specified element to the end of the vector.?Read a value from the vector, where indices are started from 0.ASet an array item at the specified index which is started from 0. Return the index of the specified element using binary search; otherwise, a negated insertion index minus one: 0 -> -0 - 1, ..., i -> -i - 1, .... 8Return the elements of the vector in an immutable array. 8Insert the element in the vector at the specified index. *Delete the element at the specified index. (Return the index of the item or -1. @Return an index of the item satisfying the predicate or -1. eRemove the specified element and return a flag indicating whether the element was found and removed.MRemove an element by the specified predicate and return the element if found.            @Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-Inferred3 The ; type represents an imperative heap-based priority queue.)Test whether the priority queue is empty.4Return the number of elements in the priority queue.Create a new priority queue.2Enqueue a new element with the specified priority..Dequeue the element with the minimal priority.-Return the element with the minimal priority.Remove the specified element from the queue and return a computation of the flag indicating whether the element was actually removed.8Note that unlike other functions it has complexity O(n).]Remove an element satisfying the predicate and return a computation of the element if found.8Note that unlike other functions it has complexity O(n). AReturn the index of the item satisfying the predicate or -1. Use  instead.Use  instead.    @Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-Inferred3;The type which values can be contained in an unboxed array.,Create an unboxed array with default values. !" !"@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-Inferred3'Represents an unboxed resizable vector.Create a new vector. Copy the vector.#2Ensure that the vector has the specified capacity.!Return the element count."3Add the specified element to the end of the vector.#?Read a value from the vector, where indices are started from 0.$ASet an array item at the specified index which is started from 0.%Return the index of the specified element using binary search; otherwise, a negated insertion index minus one: 0 -> -0 - 1, ..., i -> -i - 1, ....&8Return the elements of the vector in an immutable array.'8Insert the element in the vector at the specified index.(*Delete the element at the specified index.)(Return the index of the item or -1. *@Return an index of the item satisfying the predicate or -1. +eRemove the specified element and return a flag indicating whether the element was found and removed.,uRemove an element by the specified predicate and return a flag indicating whether the element was found and removed.$%&' #!"#$(%&'()*+, !"#$%&'()*+, !"#$%'(+,)*&$%&' #!"#$(%&'()*+,@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-Inferred -The -2 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.0Create a new list.1&Insert a new element in the beginning.2Add a new element to the end.3Remove the first element.4Remove the last element.5Return the first element.6Return the last element.7sRemove the specified element from the list and return a flag indicating whether the element was found and removed.8VRemove an element satisfying the specified predicate and return the element if found.-*+,-)./01./012345678 -./012345678 -./012347856 -*+,-)./01./012345678@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-Inferred;9;A counter for which the timing statistics is collected too.;The counter value.<The counter statistics.=4A counter for which the statistics is collected too.?The counter value.@The counter statistics.ALDefines the data type from which values we can gather the timing statistics.B(An empty statistics that has no samples.C7Add a sample with the specified time to the statistics.DReturn the average value.E Return the average square value.FReturn the variance.G?This is the timing statistics where data are bound to the time.IReturn the number of samples.JReturn the minimum value.KReturn the maximum value.LReturn the last value.M1Return the time at which the minimum is attained.N1Return the time at which the maximum is attained.O"Return the start time of sampling.P!Return the last time of sampling.QReturn the sum of values.R Return the sum of square values.SNSpecifies data type from which values we can gather the statistics. T3An empty statistics that has no samples. U#Add a new sample to the statistics.VCombine two statistics.WZDescribes when the statistics consists of only samples not bound to the simulation time.YThe total number of samples.Z$The minimum value among the samples.[$The maximum value among the samples.\The average value.]The average square value.2,Defines data types that can be converted to 3.4Convert the value to 3.^cIf allows combining statistics more efficiently if we know that the first argument can be a scalar._Return the variance.`Return the deviation. a)Return the statistics by a single sample.b4Create the statistics by the specified list of data.c5Convert the statistics from integer to double values.5*Show the summary of the statistics. dEShow the summary of the statistics using the specified indent. e#Return the deviation. f,Return the statistics by single timing data.g5Convert the statistics from integer to double values.hConvert the statistics to its normalised sampling-based representation, where the first argument specifies the number of pseudo-samples.6*Show the summary of the statistics. iEShow the summary of the statistics using the specified indent. jAn empty counter.kIncrease the counter.lDecrease the counter.m Set a new value for the counter.n2Create a counter with the specified initial value.oAn empty counter.p+Increase the counter at the specified time.q+Decrease the counter at the specified time.r6Set a new value for the counter at the specified time.sKCreate a timing counter with the specified initial value at the given time.N9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]2478^_`abc5d9:;<efgh6ijklmnopqrs=>?@ABCDE;9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs;WXYZ[\]STUV^_`dabcGHIJKLMNOPQRABCDEFeifgh=>?@jklmn9:;<opqrs.9:;<=>?@ABCDEFG HIJKLMNOPQRSTUVWXYZ[\]2478^_`abc5d9:;<efgh6ijklmnopqrs=>?@ABCDE@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-InferredHM#t.Defines a type of the random number generator.u^The custom random number generator by the specified uniform generator of numbers from 0 to 1.v#The custom random number generator.w;The simple random number generator with the specified seed.x#The simple random number generator.y"Defines a random number generator.{JGenerate an uniform random number with the specified minimum and maximum.|RGenerate an uniform integer random number with the specified minimum and maximum.}RGenerate a triangular random number by the specified minimum, median and maximum.~IGenerate the normal random number with the specified mean and deviation.Generate a random number from the lognormal distribution derived from a normal distribution with the specified mean and deviation.kGenerate the random number distributed exponentially with the specified mean (the reciprocal of the rate).kGenerate the Erlang random number with the specified scale (the reciprocal of the rate) and integer shape.<Generate the Poisson random number with the specified mean.YGenerate the binomial random number with the specified probability and number of trials.Generate a random number from the Gamma distribution with the specified shape (kappa) and scale (theta, a reciprocal of the rate).5The probability density for the Gamma distribution is If x = x ** (kappa - 1) * exp (- x / theta) / theta ** kappa * Gamma kappahGenerate a random number from the Beta distribution by the specified shape parameters (alpha and beta).4The probability density for the Beta distribution is =f x = x ** (alpha - 1) * (1 - x) ** (beta - 1) / B alpha betaYGenerate a random number from the Weibull distribution by the specified shape and scale.AGenerate a random value from the specified discrete distribution.(A discrete probability density function.FJGenerate the uniform random number with the specified minimum and maximum.GJGenerate the uniform random number with the specified minimum and maximum.HSGenerate the triangular random number by the specified minimum, median and maximum.ICreate a normal random number generator with mean 0 and variance 1 by the specified generator of uniform random numbers from 0 to 1.J=Return the exponential random number with the specified mean.K Return the Erlang random number.L;Generate the Poisson random number with the specified mean.MWGenerate a binomial random number with the specified probability and number of trials. NVGenerate a random number from the Gamma distribution using Marsaglia and Tsang method.O4Generate a random number from the Beta distribution.P7Generate a random number from the Weibull distribution.QAGenerate a random value from the specified discrete distribution.;Create a new random number generator by the specified type.BCreate a new random generator by the specified standard generator.RXCreate a new random generator by the specified uniform generator of numbers from 0 to 1.$tuvwxyz{|}~F the generatorminimummaximumG the generatorminimummaximumH the generatorminimummedianmaximumI the generatorJ the generatorthe meanK the generator the scale the shapeL the generatorthe meanM the generatorthe probabilitythe number of trialsN a normal random number ~ N (0,1)#an uniform random number ~ U (0, 1)the shape parameter (kappa) the scale parameter (theta)O!a normal random number ~ N (0, 1)#an uniform random number ~ U (0, 1)the shape parameter alphathe shape parameter betaP#an uniform random number ~ U (0, 1)shapescaleQ#an uniform random number ~ U (0, 1)'a discrete probability density functionRtuvwxyz{|}~yz{|}~txwvutxwvuyz{|}~FGHIJKLMNOPQR<@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-Inferred*SIt represents the event queue.Tthe underlying priority queueU0whether the queue is currently processing eventsV"the actual time of the event queueWIIt defines the simulation point appended with the additional information.Xthe simulation specsYthe simulation runZthe current time[the current iteration\the current phase]"It indentifies the simulation run.^the simulation specs_ the current simulation run index`+the total number of runs in this experimentathe event queuebthe random number generator"It defines the integration method. the 4th order Runge-Kutta method the 2nd order Runge-Kutta methodEuler's method It defines the simulation specs.the start time the stop timethe integration time stepthe integration method'the type of the random number generatorc0Create a new event queue by the specified specs.d6Returns the integration iterations starting from zero.2Returns the first and last integration iterations.3Returns the first integration iteration, i.e. zero.'Returns the last integration iteration.eIReturns the phases for the specified simulation specs starting from zero..Returns the first and last integration phases./Returns the first integration phase, i.e. zero.RReturns the last integration phase, 0 for Euler's method, 1 for RK2 and 3 for RK4.bReturns a simulation time for the integration point specified by the specs, iteration and phase.#Return the integration time values.f#Return the integration time points.gReturn the start time point.hReturn the stop time point.i'Return the point at the specified time.jHReturn the integration time points startin from the specified iteration..SkTUVWlXYZ[\]m^_`abcdefghij,SkTUVWlXYZ[\]m^_`abcfghijSkTUVWlXYZ[\]m^_`abcdefghij @Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-Inferred=@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-InferredC:A type class to lift the parameters to other computations.Lift the specified $ computation to another computation.The { monad that allows specifying the model parameters. For example, they can be used when running the Monte-Carlo simulation.uIn general, this monad is very useful for representing a computation which is external relative to the model itself.,Run the parameter using the specified specs.uRun the given number of parameters using the specified specs, where each parameter is distinguished by its index parameterIndex.0Return the run index for the current simulation./Return the number of simulations currently run.Return the simulation specs.:Return the random number generator for the simulation run.Exception handling within  computations..A computation with finalization part like the n function.Like the standard o function.p Invoke the  computation. Memoize the  computation, always returning the same value within a simulation run. However, the value will be recalculated for other simulation runs. Also it is thread-safe when different simulation runs are executed in parallel on physically different operating system threads. Return a parameter which value is taken consequently from the specified table based on the run index of the current simulation starting from zero. After all values from the table are used, it takes again the first value of the table, then the second one and so on.3Computation that returns the start simulation time.3Computation that returns the final simulation time.3Computation that returns the integration time step."qrstupvwxyz{|}~qp qrstupvwxyz{|}~ @Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-Inferred>@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-Inferred+:CM5An exception that signals of aborting the simulation.&The exception to abort the simulation."The root of simulation exceptions."A particular simulation exception.GA 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.wRun the given number of simulations using the specified specs, where each simulation is distinguished by its index .Return the event queue.Exception handling within  computations..A computation with finalization part like the n function.Like the standard o function. Invoke the  computation. Memoize the G computation, always returning the same value within a simulation run. @Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimental Safe-Inferred ?@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneCA type class to lift the $ computations to other computations.Lift the specified $ computation to another computation.A value in the 6 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 n function.Like the standard o function. Invoke the  computation.5Computation that returns the current simulation time.0Whether the current time is an integration time.HReturn the integration iteration closest to the current simulation time.EReturn the integration phase for the current simulation time. It is (-1)! for non-integration time points.8Show the debug message with the current simulation time.%#@@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneC',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.2Test whether the event was processed and finished.%Defines how the events are processed.either process all earlier events, 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)either process all earlier and then current events, 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)either process all earlier events not affecting the events at the current simulation time, or raise an error if the current simulation time is less than the actual time of the event queue (safe within the 5 computation as this is protected by the type system)either process all earlier and then current events, or raise an error if the current simulation time is less than the actual time of the event queue (safe within the 5 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 k monad represents a polymorphic time varying function which is strongly synchronized with the event queue.Exception handling within  computations..A computation with finalization part like the n function.Like the standard o function. Invoke the  computation.?Enqueue the event which must be actuated at the specified time.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 8 computation in the current simulation time within the $ computation involving all pending  in the processing too.Run the 8 computation in the current simulation time within the S computation specifying what pending events should be involved in the processing.Run the 6 computation in the start time involving all pending  in the processing too.Run the 5 computation in the stop time involving all pending  in the processing too.AReturn the number of pending events that should be yet actuated.7Actuate the event handler in the specified time points.7Actuate the event handler in the specified time points.9Actuate the event handler in the integration time points./Enqueue the event with an ability to cancel it. Memoize the G computation, always returning the same value within a simulation run. Memoize the  computation, always returning the same value 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  computation is always synchronized with the event queue which time flows in one direction only. This synchronization is a key difference between the  and  computations.REnqueue the event which must be actuated with the current modeling time but later.8Show the debug message with the current simulation time.:".@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneThe 3 type represents a mutable variable similar to the  variable 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. @Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone"@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone68=K!8Strategy: 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).:Defines a strategy with support of the deleting operation.[Remove the element and return a flag indicating whether the element was found and removed.KRemove an element satisfying the predicate and return the element if found.QIt defines a strategy when we can enqueue an element with the specified priority./Enqueue 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.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 element)whether the element was found and removed the queue the predicate'the element if it was found and removed the queue the prioritythe element to be enqueuedthe action of enqueuing the queuethe element to be enqueuedthe action of enqueuing the queuethe dequeued element the strategy a new queue the queuethe result of the test     -          A@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneNIt defines when an event has arrived, usually generated by some random stream.Such events should arrive one by one without time lag in the following sense that the model should start awaiting the next event exactly in that time when the previous event has arrived.TAnother use case is a situation when the actual event is not synchronized with the  computation, being synchronized with the event queue, nevertheless. 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 2the simulation time at which the event has arrived!Mthe delay time which has passed from the time of arriving the previous event ! ! !@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone*"BDescribes a computation that also signals when changing its value.$"Return a computation of the value.%tReturn 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.(/The signal that can have disposable handlers. *Subscribe the handler to the specified signal and return a nested computation within a disposable object that, being applied, unsubscribes the handler from this signal.+.The signal source that can publish its signal.,Publish the signal.-WTrigger the signal actuating all its handlers at the current simulation time point..kSubscribe the handler to the specified signal forever. To subscribe the disposable handlers, use function *./Create a new signal source.!Trigger all next signal handlers.KEnqueue the handler and return its representative in the queue. #Dequeue the handler representative.00Map the signal according the specified function.1GFilter only those signal values that satisfy the specified predicate.2dFilter only those signal values that satisfy the specified predicate, but then ignoring the values.3FFilter only those signal values that satisfy the specified predicate.4dFilter only those signal values that satisfy the specified predicate, but then ignoring the values.5Merge two signals.6Merge three signals.7Merge four signals.8Merge five signals.9Compose the signal.:Transform the signal.;)An empty signal which is never triggered.<&Create a history of the signal values.=PCreate 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.@dReturn a signal that is triggered in the integration time points. It should be called with help of .AWReturn a signal that is triggered in the start time. It should be called with help of .B4Return a signal that is triggered in the final time.C5Return a signal notifying that the value has changed.DReturn an identity.EAn associative operation.FTransform a signal so that the resulting signal returns a sequence of arrivals saving the information about the time points at which the original signal was received.G8Show the debug message with the current simulation time.:"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG&"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG)()*.+,-/,-09:1234;5678F?@AB&''<=>"#$%CDEG)"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneHThe H3 type represents a mutable variable similar to the  variable but only dependent on the event queue, which allows synchronizing the reference with the model explicitly through the  monad.ICreate a new reference.JRead the value of a reference.K%Write a new value into the reference.L%Mutate the contents of the reference.MHReturn a signal that notifies about every change of the reference state.NHReturn a signal that notifies about every change of the reference state. HIJKLMNHIJKLMNHMNIJKLHIJKLMN@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone O Like the HL reference but keeps the history of changes in different time points. The OK variable is safe to be used in the hybrid discrete-continuous simulation.For example, the memoised values of a variable can be used in the differential or difference equations of System Dynamics, while the variable iself can be updated wihin the discrete event simulation.5Only this variable is much slower than the reference.PCreate a new variable.QRead the first actual, i.e. memoised, value of a variable for the requested time actuating the current events from the queue if needed.gThis computation can be used in the ordinary differential and difference equations of System Dynamics.RBRead the recent actual value of a variable for the requested time.HThis computation is destined for using within discrete event simulation.S$Write a new value into the variable.T$Mutate the contents of the variable.U*Freeze the variable and return in arrays the time points and corresponded first and last values when the variable had changed or had been memoised in different time points: (1) the time points are sorted in ascending order; (2) the first and last actual values per each time point are provided.}If 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 V% signal to it and then call function >.VGReturn a signal that notifies about every change of the variable state.WGReturn a signal that notifies about every change of the variable state.OPQRSTUVW OPQRSTUVW OVWPRQSTU OPQRSTUVW@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone X Like the HL reference but keeps the history of changes in different time points. The XK variable is safe to be used in the hybrid discrete-continuous simulation.For example, the memoised values of a variable can be used in the differential or difference equations of System Dynamics, while the variable iself can be updated wihin the discrete event simulation.5Only this variable is much slower than the reference.YCreate a new variable.ZRead the first actual, i.e. memoised, value of a variable for the requested time actuating the current events from the queue if needed.gThis computation can be used in the ordinary differential and difference equations of System Dynamics.[BRead the recent actual value of a variable for the requested time.HThis computation is destined for using within discrete event simulation.\$Write a new value into the variable.]$Mutate the contents of the variable.^*Freeze the variable and return in arrays the time points and corresponded first and last values when the variable had changed or had been memoised in different time points: (1) the time points are sorted in ascending order; (2) the first and last actual values per each time point are provided.}If 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 >._GReturn a signal that notifies about every change of the variable state.`GReturn a signal that notifies about every change of the variable state.XYZ[\]^_` XYZ[\]^_` X_`Y[Z\]^ XYZ[\]^_`B@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone7,Represents a temporarily frozen computation.Unfreeze the computation.&The auxiliary continuation parameters.The continuation parameters.aThe a! type is similar to the standard Cont] monad and F# async workflow but only the result of applying the continuations return the  computation.!The event that occurs within the a computation.4Proceed with the computation after if was preempted.Preempt the computation.Cancel the computation.It identifies the a computation.bEIt defines how the parent and child computations should be cancelled.c%Cancel the computations in isolation.d,Cancel the parent if its child is cancelled.e,Cancel the child if its parent is cancelled.f&Cancel the both computations together. Create a computation identifier.*Signal when the computation state changes.*Signal when the cancellation is intiating.'Whether the cancellation was initiated.'Whether the cancellation was activated.Deactivate the cancellation.TIf the main computation is cancelled then all the nested ones will be cancelled too.0Connect the parent computation to the child one.Initiate the cancellation.Preempt the computation.<Proceed with the computation after it was preempted earlier.)Signal when the computation is preempted.GSignal when the computation is proceeded after it was preempted before.&Whether the computation was preemtped.Invoke the computation.Cancel the computation.Like return a >>= k.Exception handling within a computations.%A computation with finalization part.8Throw the exception with the further exception handling.>By some reason, an exception raised with help of the standard o* function is not handled properly within aN computation, altough it will be still handled if it will be wrapped in the Z monad. Therefore, you should use specialised functions like the stated one that use the o function but within the ; computation, which allows already handling the exception.Run the ax computation with the specified cancelation source and flag indicating whether to catch exceptions from the beginning. Lift the  computation. Lift the  computation. Lift the  computation. Lift the  computation. Lift the IO computation. 3Resume the computation by the specified parameters. :Resume the exception handling by the specified parameters. )Test whether the computation is canceled. RExecute the specified computations in parallel within the current computation and return their results. The cancellation of any of the nested computations affects the current computation. The exception raised in any of the nested computations is propogated 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 they are processed simultaneously by the event queue.A partial case of  | when we are not interested in the results but we are interested in the actions to be peformed by the nested computations. Rerun the a+ computation with the specified identifier.Run the a6 computation in parallel but connect the computations..Freeze the computation parameters temporarily.aFreeze the computation parameters specifying what should be done when reentering the computation./Reenter the computation parameters when needed.8Sleep until the preempted computation will be reentered.Substitute the continuation.Await the signal.8Show the debug message with the current simulation time.T !a"#$%&'bcdef the parenthow to connect the child%computation of the disposable handler()the computation to runthe main branch !the branch for handing exceptionsthe branch for cancellationthe computation identifier<whether to support the exception handling from the beginning *+    Athe list of: the nested computation, the computation identifierAthe list of: the nested computation, the computation identifier,-./01234.a"bcdef    < !a"#$%&'bfedc() *+    ,-./01234C@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone95The result of memoization.gA type class to lift the i# computation to other computations.hLift the specified i$ computation to another computation.iVSpecifies a discontinuous process that can suspend at any time and then resume later.j Represents a process identifier.6Invoke the process computation.k/Hold the process for the specified time period.lYInterrupt a process with the specified identifier if the process is held by computation k.mGTest whether the process with the specified identifier was interrupted.7NDefine a reaction when the process with the specified identifier is preempted.nPassivate the process.oETest whether the process with the specified identifier is passivated.p3Reactivate a process with the specified identifier.8-Prepare the processes identifier for running.q#Run immediately the process. A new j- identifier will be assigned to the process.;To run the process at the specified time, you can use the w function.rRun immediately the process with the specified identifier. It will be more efficient than as you would specify the process identifier with help of the  combinator and then would call q.;To run the process at the specified time, you can use the x function.sERun the process in the start time immediately involving all pending  in the computation too.thRun the process in the start time immediately using the specified identifier and involving all pending  in the computation too.uPRun the process in the final simulation time immediately involving all pending  in the computation too.vtRun the process in the final simulation time immediately using the specified identifier and involving all pending  in the computation too.wZEnqueue the process that will be then started at the specified time from the event queue.xZEnqueue the process that will be then started at the specified time from the event queue.y&Return the current process identifier.z Create a new process identifier.{JCancel a process with the specified identifier, interrupting it if needed.|The process cancels itself.}ETest whether the process with the specified identifier was cancelled.~[Return a signal that notifies about cancelling the process with the specified identifier.RRegister a handler that will be invoked in case of cancelling the current process.90Preempt a process with the specified identifier.:[Proceed with the process with the specified identifier after it was preempted with help of preemptProcessBegin..Return a signal when the process is preempted.MReturn a signal when the process is proceeded after it was preempted earlier.Exception handling within i computations.%A computation with finalization part.8Throw the exception with the further exception handling.>By some reason, an exception raised with help of the standard o* function is not handled properly within iN computation, altough it will be still handled if it will be wrapped in the Z monad. Therefore, you should use specialised functions like the stated one that use the o function but within the ; computation, which allows already handling the exception.(Execute the specified computations in parallel within the current computation and return their results. The cancellation of any of the nested computations affects the current computation. 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 they are processed simultaneously by the event queue.New j7 identifiers will be assigned to the started processes.Like  but allows specifying the process identifiers. It will be more efficient than as you would specify the process identifiers with help of the  combinator and then would call .Like  but ignores the result.Like  but ignores the result.;#Create the new process identifiers.<-Prepare the processes for parallel execution.Allow calling the process with the specified identifier. It creates a nested process when canceling any of two, or raising an IO+ exception in any of the both, affects the i computation.^At the same time, the interruption has no such effect as it requires explicit specifying the j identifier of the nested process itself, that is the nested process cannot be interrupted using only the parent process identifier.jSpawn the child process. In case of cancelling one of the processes, other process will be cancelled too.Spawn the child process with the specified process identifier. In case of cancelling one of the processes, other process will be cancelled too.kSpawn the child process specifying how the child and parent processes should be cancelled in case of need.kSpawn the child process specifying how the child and parent processes should be cancelled in case of need.Await the signal.]Memoize the process so that it would always return the same value within the simulation run.0Zip two parallel processes waiting for the both.7Zip three parallel processes waiting for their results.Unzip the process using memoization so that the both returned processes could be applied independently, although they will refer to the same pair of values.Try to run the child process within the specified timeout. If the process will finish successfully within this time interval then the result wrapped in =G 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.YA cancellation of the child process doesn't lead to cancelling the parent process. Then >$ is returned within the computation.Try to run the child process with the given identifier within the specified timeout. If the process will finish successfully within this time interval then the result wrapped in =G 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.YA cancellation of the child process doesn't lead to cancelling the parent process. Then >$ is returned within the computation.Yield to allow other i and ; computations to run at the current simulation time point.A computation that never computes the result. It behaves like a black hole for the discontinuous process, although such a process can still be canceled outside (see {-), but then only its finalization parts (see E) will be called, usually, to release the resources acquired before.8Show the debug message with the current simulation time.V5?@AghiBjCDEFGHIJ6klm7nop8qrstuvwxyz{|}~9:KLMNOPQ;<RSTUVWXYZ[5ghiBj6klmnopqrstuvwxyz{|}~9:I5A@?ghiBjCDEFGHIJ6klm7nop8qrstuvwxyz{|}~9:KLMNOPQ;<RSTUVWXYZ[@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone1ghijklmnopqrstuvwxyz{|}~1jighqrstuvwxzyklmnop{|}~@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone 8Represents a gate, which can be either opened or closed.ACreate a new gate, specifying whether the gate is initially open.!Create a new initially open gate."Create a new initially close gate.Open the gate if it was closed.Close the gate if it was open.Test whether the gate is open. Test whether the gate is closed.oAwait the gate to be opened if required. If the gate is already open then the computation returns immediately.qAwait the gate to be closed if required. If the gate is already closed then the computation returns immediately.4Signal triggered when the state of the gate changes. \]   \]@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone1&Represents the resource with strategy s" applied for queuing the requests.5Return the strategy applied for queuing the requests.0Return the maximum count of the resource, where >- means that the resource has no upper bound.$The resource with static priorities.-The SIRO (Serviced in Random Order) resource.8The ordinary LCFS (Last Come - First Serviced) resource.9The ordinary FCFS (First Come - First Serviced) resource.iCreate a new FCFS resource with the specified initial count which value becomes the upper bound as well.QCreate a new FCFS resource with the specified initial and maximum counts, where >, means that the resource has no upper bound.iCreate a new LCFS resource with the specified initial count which value becomes the upper bound as well.QCreate a new LCFS resource with the specified initial and maximum counts, where >, means that the resource has no upper bound.iCreate a new SIRO resource with the specified initial count which value becomes the upper bound as well.QCreate a new SIRO resource with the specified initial and maximum counts, where >, means that the resource has no upper bound.mCreate a new priority resource with the specified initial count which value becomes the upper bound as well.UCreate a new priority resource with the specified initial and maximum counts, where >, means that the resource has no upper bound.{Create a new resource with the specified queue strategy and initial count. The last value becomes the upper bound as well.\Create a new resource with the specified queue strategy, initial and maximum counts, where >, means that the resource has no upper bound.3Return the current available count of the resource.>Return the statistics for the available count of the resource.Signal triggered when the  property changes.Signal triggered when the  property changes.5Return the current utilisation count of the resource.@Return the statistics for the utilisation count of the resource.Signal triggered when the  property changes.Signal triggered when the  property changes.0Return the current queue length of the resource.;Return the statistics for the queue length of the resource.Signal triggered when the  property changes.Signal triggered when the  property changes.+Return the total wait time of the resource.8Return the statistics for the wait time of the resource.Signal triggered when the  and  properties change.Signal triggered when the  and  properties change.Request for the resource decreasing its count in case of success, otherwise suspending the discontinuous process until some other process releases the resource.Request with the priority for the resource decreasing its count in case of success, otherwise suspending the discontinuous process until some other process releases the resource.nRelease the resource increasing its count and resuming one of the previously suspended processes as possible.nRelease the resource increasing its count and resuming one of the previously suspended processes as possible.^7Release the resource without affecting its utilisation.WTry to request for the resource decreasing its count in case of success and returning _ in the  monad; otherwise, returning `.rAcquire the resource, perform some action and safely release the resource in the end, even if the a was raised within the action. Acquire the resource with the specified priority, perform some action and safely release the resource in the end, even if the a was raised within the action.b)Decrease the count of available resource.mIncrease the count of available resource by the specified number, invoking the awaiting processes as needed.~Decrease the count of available resource by the specified number, waiting for the processes capturing the resource as needed.;Signal triggered when one of the resource counters changes.c-Update the resource count and its statistics.d9Update the resource utilisation count and its statistics.e4Update the resource queue length and its statistics.f1Update the resource wait time and its statistics.Dghijklmnopqrstuvwx9the initial count (and maximal count too) of the resource!the initial count of the resource:the maximum count of the resource, which can be indefinite9the initial count (and maximal count too) of the resource!the initial count of the resource:the maximum count of the resource, which can be indefinite9the initial count (and maximal count too) of the resource!the initial count of the resource:the maximum count of the resource, which can be indefinite9the initial count (and maximal count too) of the resource!the initial count of the resource:the maximum count of the resource, which can be indefinite.the strategy for managing the queuing requests9the initial count (and maximal count too) of the resource.the strategy for managing the queuing requests!the initial count of the resource:the maximum count of the resource, which can be indefinitethe requested resourcethe requested resource the prioritythe resource to releasethe resource to release^the resource to release(the resource which we try to request forDthe resource we are going to request for and then release in the end4the action we are going to apply having the resourcethe result of the actionEthe resource we are going to request for and then release in the end the priority4the action we are going to apply having the resourcethe result of the actionb,the resource for which to decrease the count the resource$the increment for the resource count the resource$the decrement for the resource countcdefy+-1ghijklmnopqrstuvwx^bcdefy@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone&Represents the resource with strategy s" applied for queuing the requests.5Return the strategy applied for queuing the requests.0Return the maximum count of the resource, where >- means that the resource has no upper bound.$The resource with static priorities.-The SIRO (Serviced in Random Order) resource.8The ordinary LCFS (Last Come - First Serviced) resource.9The ordinary FCFS (First Come - First Serviced) resource.iCreate a new FCFS resource with the specified initial count which value becomes the upper bound as well.QCreate a new FCFS resource with the specified initial and maximum counts, where >, means that the resource has no upper bound.iCreate a new LCFS resource with the specified initial count which value becomes the upper bound as well.QCreate a new LCFS resource with the specified initial and maximum counts, where >, means that the resource has no upper bound.iCreate a new SIRO resource with the specified initial count which value becomes the upper bound as well.QCreate a new SIRO resource with the specified initial and maximum counts, where >, means that the resource has no upper bound.mCreate a new priority resource with the specified initial count which value becomes the upper bound as well.UCreate a new priority resource with the specified initial and maximum counts, where >, means that the resource has no upper bound.{Create a new resource with the specified queue strategy and initial count. The last value becomes the upper bound as well.\Create a new resource with the specified queue strategy, initial and maximum counts, where >, means that the resource has no upper bound.)Return the current count of the resource.Request for the resource decreasing its count in case of success, otherwise suspending the discontinuous process until some other process releases the resource.Request with the priority for the resource decreasing its count in case of success, otherwise suspending the discontinuous process until some other process releases the resource.nRelease the resource increasing its count and resuming one of the previously suspended processes as possible.nRelease the resource increasing its count and resuming one of the previously suspended processes as possible.WTry to request for the resource decreasing its count in case of success and returning _ in the  monad; otherwise, returning `.rAcquire the resource, perform some action and safely release the resource in the end, even if the a was raised within the action. Acquire the resource with the specified priority, perform some action and safely release the resource in the end, even if the a was raised within the action.mIncrease the count of available resource by the specified number, invoking the awaiting processes as needed.~Decrease the count of available resource by the specified number, waiting for the processes capturing the resource as needed.z{|9the initial count (and maximal count too) of the resource!the initial count of the resource:the maximum count of the resource, which can be indefinite9the initial count (and maximal count too) of the resource!the initial count of the resource:the maximum count of the resource, which can be indefinite9the initial count (and maximal count too) of the resource!the initial count of the resource:the maximum count of the resource, which can be indefinite9the initial count (and maximal count too) of the resource!the initial count of the resource:the maximum count of the resource, which can be indefinite.the strategy for managing the queuing requests9the initial count (and maximal count too) of the resource.the strategy for managing the queuing requests!the initial count of the resource:the maximum count of the resource, which can be indefinitethe requested resourcethe requested resource the prioritythe resource to releasethe resource to release(the resource which we try to request forDthe resource we are going to request for and then release in the end4the action we are going to apply having the resourcethe result of the actionEthe resource we are going to request for and then release in the end the priority4the action we are going to apply having the resourcethe result of the action the resource$the increment for the resource count the resource$the decrement for the resource count}z{|}@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone"Represents the result of the task.the task was cancelled<the specified exception was raised when performing the task.Ithe task was successfully completed and it returned the specified resultEThe task represents a process that was already started in background.TReturn an identifier for the process that was launched in background for this task.~*It contains the result of the computation.FReturn a signal that notifies about receiving the result of the task.:Try to get the task result immediately without suspension.@Return the task result suspending the outer process if required.Cancel the task.$Test whether the task was cancelled.:Create a task by the specified process and its identifier.jRun the process with the specified identifier in background and return the corresponded task immediately.KRun the process in background and return the corresponded task immediately.Enqueue the process that will be started at the specified time with the given identifier from the event queue. It returns the corresponded task immediately.Enqueue the process that will be started at the specified time from the event queue. It returns the corresponded task immediately.oRun using the specified identifier a child process in background and return immediately the corresponded task.ORun a child process in background and return immediately the corresponded task.oRun using the specified identifier a child process in background and return immediately the corresponded task.ORun a child process in background and return immediately the corresponded task.Return an outer process that behaves like the task itself, for example, when the task is cancelled if the outer process is cancelled. (Return the result of two parallel tasks.{Return an outer process for two parallel tasks returning the result of the first finished task and the rest task in pair. ~~@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone'Idenitifies an item that was preempted.3Idenitifies an item that requests for the resource.QIdenitifies an awaiting item that waits for releasing of the resource to take it.5Identifies an acting item that acquired the resource."Represents a preemptible resource.0Return the maximum count of the resource, where >- means that the resource has no upper bound.\Create a new resource with the specified initial count that becomes the upper bound as well.LCreate a new resource with the specified initial and maximum counts, where >, means that the resource has no upper bound.)Return the current count of the resource.Request with the priority for the resource decreasing its count in case of success, otherwise suspending the discontinuous process until some other process releases the resource.It may preempt another process if the latter aquired the resource before but had a lower priority. Then the current process takes an ownership of the resource.{Release the resource increasing its count and resuming one of the previously suspended or preempted processes as possible.{Release the resource increasing its count and resuming one of the previously suspended or preempted processes as possible.Acquire the resource with the specified priority, perform some action and safely release the resource in the end, even if the a was raised within the action.~Preempt a process with the lowest priority that acquires yet the resource and decrease the count of available resource by 1. Increase the count of available resource by the specified number, invoking the awaiting and preempted processes according to their priorities as needed.Decrease the count of available resource by the specified number, preempting the processes according to their priorities as needed. HAlter the resource count either increasing or decreasing it by calling  or  respectively. !9the initial count (and maximal count too) of the resource!the initial count of the resource:the maximum count of the resource, which can be indefinitethe requested resource3the priority (the less value has a higher priority)the resource to releasethe resource to releaseEthe resource we are going to request for and then release in the end3the priority (the less value has a higher priority)4the action we are going to apply having the resourcethe result of the action the resource$the increment for the resource count the resource$the decrement for the resource count  the resourcea change of the resource count    @Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoned-Stores the item and a time of its enqueuing. Return the item value.&Return the time of enqueuing the item.-Return the time of storing in the queue, or  itemInputTime< before the actual storing when the item was just enqueued. JRepresents a queue using the specified strategies for enqueueing (input), si!, internal storing (in memory), sm, and dequeueing (output), so, where a0 denotes the type of items stored in the queue. The queue capacity. PThe strategy applied to the enqueueing (input) processes when the queue is full. AThe strategy applied when storing (in memory) items in the queue.RThe strategy applied to the dequeueing (output) processes when the queue is empty.dA 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.fA type synonym for the ordinary LIFO queue also known as the LCFS (Last Come - First Serviced) queue.gA type synonym for the ordinary FIFO queue also known as the FCFS (First Come - First Serviced) queue.6Create a new FCFS queue with the specified capacity. 6Create a new LCFS queue with the specified capacity. 6Create a new SIRO queue with the specified capacity. :Create a new priority queue with the specified capacity. @Create 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.(8Return 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, 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..DReturn the total number of output items that were actually dequeued. See also / and 0./Signal when the . property value has changed.0Signal when the . property value has changed.1CReturn the load factor: the queue size divided by its maximum size. See also 2 and 3.2Signal when the 1 property value has changed.3Signal when the 1 property value has changed.4PReturn the rate of the input items that were enqueued: how many items per time.5HReturn the rate of the items that were stored: how many items per time.6Return the rate of the requests for dequeueing the items: how many requests per time. It does not include the failed attempts to dequeue immediately without suspension.7ZReturn the rate of the output items that were actually dequeued: how many items per time.8sReturn 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 9 and :.9Signal when the 8 property value has changed.:Signal when the 8 property value has changed.;Return 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, 5queueTotalWaitTime == enqueueWaitTime + queueWaitTime. See also < and =.<Signal when the ; property value has changed.=Signal when the ; property value has changed.>Return the enqueue wait time from the time at which the enqueueing operation 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.AReturn 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 B and C.BSignal when the A property value has changed.CSignal when the A property value has changed.DmReturn a long-term average queue rate calculated as the average queue size divided by the average wait time.This value may be less than the actual arrival rate as the queue is finite and new arrivals may be locked while the queue remains full. See also E and F.ESignal when the D property value has changed.FSignal when the D property value has changed.G5Dequeue suspending the process if the queue is empty.HNDequeue with the output priority suspending the process if the queue is empty.ITry to dequeue immediately.JmRemove the item from the queue and return a flag indicating whether the item was found and actually removed.K)Remove the specified item from the queue.LORemove an item satisfying the specified predicate and return the item if found.M2Remove an item satisfying the specified predicate.NClear the queue immediately.O?Enqueue the item suspending the process if the queue is full. PWEnqueue with the input priority the item suspending the process if the queue is full. QYEnqueue with the storing priority the item suspending the process if the queue is full. ReEnqueue with the input and storing priorities the item suspending the process if the queue is full. S Try to enqueue the item. Return `# in the monad if the queue is full.T:Try to enqueue with the storing priority the item. Return `$ in the monad if the queue is full.UNTry to enqueue the item. If the queue is full then the item will be lost and ` will be returned.VhTry to enqueue with the storing priority the item. If the queue is full then the item will be lost and ` will be returned.WITry to enqueue the item. If the queue is full then the item will be lost.XdTry to enqueue with the storing priority the item. If the queue is full then the item will be lost.YHReturn a signal that notifies when the enqueuing operation is initiated.ZReturn a signal that notifies when the enqueuing operation is completed and the item is stored in the internal memory of the queue.[rReturn a signal which notifies that the item was lost when attempting to add it to the full queue with help of U, W` or similar functions that imply that the element can be lost. All their names are ending with OrLost or OrLost_. In other cases the enqueued items are not lost but the corresponded process can suspend until the internal queue storage is freed. Although there is one exception from this rule. If the process trying to enqueue a new element was suspended but then canceled through |3 from the outside then the item will not be added.\IReturn a signal that notifies when the dequeuing operation was requested.]Return a signal that notifies when the item was extracted from the internal storage of the queue and prepared for immediate receiving by the dequeuing process.+Initiate the process of enqueuing the item.Store the item.!Store with the priority the item.Deny the enqueuing.IUpdate the statistics for the input wait time of the enqueuing operation.DAccept the dequeuing request and return the current simulation time.,Extract an item for the dequeuing request. CA post action after extracting the item by the dequeuing request. uUpdate 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._2Signal whenever any property of the queue changes.The property must have the corresponded signal. There are also characteristics similar to the properties but that have no signals. As a rule, such characteristics already depend on the simulation time and therefore they may change at any time point.`nReturn the summary for the queue with desciption of its properties and activities using the specified indent.y    Othe strategy applied to the enqueueing (input) processes when the queue is full4the strategy applied when storing items in the queueQthe strategy applied to the dequeueing (output) processes when the queue is emptythe queue capacity !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG the queuethe dequeued valueH the queuethe priority for outputthe dequeued valueI the queuethe dequeued value of >J the queue!the item to remove from the queue&whether the item was found and removedK the queue!the item to remove from the queueL the queue the predicateM the queue the predicateN the queueO the queuethe item to enqueueP the queuethe priority for inputthe item to enqueueQ the queuethe priority for storingthe item to enqueueR the queuethe priority for inputthe priority for storingthe item to enqueueS the queue the item which we try to enqueueT the queuethe priority for storing the item which we try to enqueueU the queue the item which we try to enqueueV the queuethe priority for storing the item which we try to enqueueW the queue the item which we try to enqueueX the queuethe priority for storing the item which we try to enqueueYZ[\] the queuethe item to be enqueued the queuethe item to be stored the queuethe priority for storingthe item to be enqueued the queuethe item to be denied the queuethe item and its input time%the action of updating the statistics the queuethe current time the queue!the time of the dequeuing requestthe dequeued value the queue!the time of the dequeuing requestthe item to dequeuethe dequeued value the queue!the time of the dequeuing requestthe item and its input time%the action of updating the statistics^_`W     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`[       "%(+.145678;>ADGHIOPQRSTUWVXJKLMN^` !#$&')*,-/0239:<=?@BCEFYZ[\]_]     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone@-Stores the item and a time of its enqueuing. Return the item value.(Return the time of storing in the queue.a_Represents an infinite queue using the specified strategies for internal storing (in memory), sm, and dequeueing (output), so, where a0 denotes the type of items stored in the queue.bAThe strategy applied when storing (in memory) items in the queue.c:The strategy applied to the dequeueing (output) processes.ddA type synonym for the queue with static priorities applied when storing the elements in the queue.e=A type synonym for the SIRO (Serviced in Random Order) queue.ffA type synonym for the ordinary LIFO queue also known as the LCFS (Last Come - First Serviced) queue.ggA type synonym for the ordinary FIFO queue also known as the FCFS (First Come - First Serviced) queue.h#Create a new infinite FCFS queue. i#Create a new infinite LCFS queue. j#Create a new infinite SIRO queue. k'Create a new infinite priority queue. l<Create a new infinite queue with the specified strategies. m Test whether the queue is empty. See also n and o.nSignal when the m property value has changed.oSignal when the m property value has changed.pReturn the current queue size. See also q, r and s.q!Return the queue size statistics.rSignal when the p property value has changed.sSignal when the p property value has changed.t8Return the total number of input items that were stored. See also u and v.uSignal when the t property value has changed.vSignal when the t property value has changed.wReturn the total number of requests for dequeueing the items, not taking into account the failed attempts to dequeue immediately without suspension. See also x and y.xSignal when the w property value has changed.ySignal when the w property value has changed.zDReturn the total number of output items that were actually dequeued. See also { and |.{Signal when the z property value has changed.|Signal when the z property value has changed.}HReturn the rate of the items that were stored: how many items per time.~Return the rate of the requests for dequeueing the items: how many requests per time. It does not include the failed attempts to dequeue immediately without suspension.QReturn the rate of the output items that were dequeued: how many items per time.sReturn 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.Return 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.mReturn 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.5Dequeue suspending the process if the queue is empty.NDequeue with the output priority suspending the process if the queue is empty.Try to dequeue immediately.mRemove the item from the queue and return a flag indicating whether the item was found and actually removed.)Remove the specified item from the queue.ORemove an item satisfying the specified predicate and return the item if found.2Remove an item satisfying the specified predicate.Clear the queue immediately.Enqueue the item. -Enqueue with the storing priority the item. dReturn a signal that notifies when the enqueued item is stored in the internal memory of the queue.IReturn a signal that notifies when the dequeuing operation was requested.Return a signal that notifies when the item was extracted from the internal storage of the queue and prepared for immediate receiving by the dequeuing process.Store the item.!Store with the priority the item.DAccept the dequeuing request and return the current simulation time.,Extract an item for the dequeuing request. CA post action after extracting the item by the dequeuing request. uUpdate the statistics for the output wait time of the dequeuing operation and the wait time of storing in the queue.2Signal whenever any property of the queue changes.The property must have the corresponded signal. There are also characteristics similar to the properties but that have no signals. As a rule, such characteristics already depend on the simulation time and therefore they may change at any time point.nReturn the summary for the queue with desciption of its properties and activities using the specified indent.Nabcdefghijkl4the strategy applied when storing items in the queueQthe strategy applied to the dequeueing (output) processes when the queue is emptymnopqrstuvwxyz{|}~ the queuethe dequeued value the queuethe priority for outputthe dequeued value the queuethe dequeued value of > the queue!the item to remove from the queue&whether the item was found and removed the queue!the item to remove from the queue the queue the predicate the queue the predicate the queue the queuethe item to enqueue the queuethe priority for storingthe item to enqueue the queuethe item to be stored the queuethe priority for storingthe item to be enqueued the queuethe current time the queue!the time of the dequeuing requestthe dequeued value the queue!the time of the dequeuing requestthe item to dequeuethe dequeued value the queue!the time of the dequeuing requestthe item and its input time%the action of updating the statistics7abcdefghijklmnopqrstuvwxyz{|}~9gfedabchijklbcmpqtwz}~norsuvxy{|<abcdefghijklmnopqrstuvwxyz{|}~@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone%'Idenitifies an item that was preempted.3Idenitifies an item that requests for the resource.QIdenitifies an awaiting item that waits for releasing of the resource to take it.5Identifies an acting item that acquired the resource."Represents a preemptible resource.0Return the maximum count of the resource, where >- means that the resource has no upper bound.\Create a new resource with the specified initial count that becomes the upper bound as well.LCreate a new resource with the specified initial and maximum counts, where >, means that the resource has no upper bound.3Return the current available count of the resource.>Return the statistics for the available count of the resource.Signal triggered when the  property changes.Signal triggered when the  property changes.5Return the current utilisation count of the resource.@Return the statistics for the utilisation count of the resource.Signal triggered when the  property changes.Signal triggered when the  property changes.0Return the current queue length of the resource.;Return the statistics for the queue length of the resource.Signal triggered when the  property changes.Signal triggered when the  property changes.+Return the total wait time of the resource.8Return the statistics for the wait time of the resource.Signal triggered when the  and  properties change.Signal triggered when the  and  properties change.Request with the priority for the resource decreasing its count in case of success, otherwise suspending the discontinuous process until some other process releases the resource.It may preempt another process if the latter aquired the resource before but had a lower priority. Then the current process takes an ownership of the resource.{Release the resource increasing its count and resuming one of the previously suspended or preempted processes as possible.{Release the resource increasing its count and resuming one of the previously suspended or preempted processes as possible.Acquire the resource with the specified priority, perform some action and safely release the resource in the end, even if the a was raised within the action.~Preempt a process with the lowest priority that acquires yet the resource and decrease the count of available resource by 1. Increase the count of available resource by the specified number, invoking the awaiting and preempted processes according to their priorities as needed.Decrease the count of available resource by the specified number, preempting the processes according to their priorities as needed.HAlter the resource count either increasing or decreasing it by calling  or  respectively.;Signal triggered when one of the resource counters changes.-Update the resource count and its statistics.4Update the resource queue length and its statistics.9Update the resource utilisation count and its statistics.1Update the resource wait time and its statistics.B9the initial count (and maximal count too) of the resource!the initial count of the resource:the maximum count of the resource, which can be indefinitethe requested resource3the priority (the less value has a higher priority)the resource to releasethe resource to releaseEthe resource we are going to request for and then release in the end3the priority (the less value has a higher priority)4the action we are going to apply having the resourcethe result of the action the resource$the increment for the resource count the resource$the decrement for the resource count the resourcea change of the resource count&@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneCReturn the initial value.:Discretize the computation in the integration time points.SInterpolate the computation based on the integration time points only. Unlike the ` function it knows about the intermediate time points that are used in the Runge-Kutta method.Like the standard  function but applied to values in the integration time points. The accumulator values are transformed according to the second argument, which should be either function  memo0Dynamics or its unboxed version.Like the standard  function but applied to values in the integration time points. The accumulator values are transformed according to the third argument, which should be either function  memo0Dynamics or its unboxed version. @Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone)Create a boxed array with default values.Memoize and order the computation in the integration time points using the interpolation that knows of the Runge-Kutta method. The values are calculated sequentially starting from .MMemoize and order the computation in the integration time points using the 1 interpolation. It consumes less memory than the  function but it is not aware of the Runge-Kutta method. There is a subtle difference when we request for values in the intermediate time points 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 K 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.!@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone3Memoize and order the computation in the integration time points using the interpolation that knows of the Runge-Kutta method. The values are calculated sequentially starting from .MMemoize and order the computation in the integration time points using the 1 interpolation. It consumes less memory than the  function but it is not aware of the Runge-Kutta method. There is a subtle difference when we request for values in the intermediate time points that are used by this method to integrate. In general case you should prefer the  function above ."@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone yComputation that generates random numbers distributed uniformly and memoizes the numbers in the integration time points.Computation that generates random integer numbers distributed uniformly and memoizes the numbers in the integration time points.Computation that generates random numbers from the triangular distribution and memoizes the numbers in the integration time points.xComputation that generates random numbers distributed normally and memoizes the numbers in the integration time points.Computation that generates random numbers from the lognormal distribution and memoizes the numbers in the integration time points.Computation that generates exponential random numbers with the specified mean (the reciprocal of the rate) and memoizes the numbers in the integration time points.Computation that generates the Erlang random numbers with the specified scale (the reciprocal of the rate) and integer shape but memoizes the numbers in the integration time points.Computation that generats the Poisson random numbers with the specified mean and memoizes the numbers in the integration time points.Computation that generates binomial random numbers with the specified probability and trials but memoizes the numbers in the integration time points.Computation that generates random numbers from the Gamma distribution with the specified shape and scale but memoizes the numbers in the integration time points.Computation that generates random numbers from the Beta distribution by the specified shape parameters and memoizes the numbers in the integration time points.Computation that generates random numbers from the Weibull distribution with the specified shape and scale but memoizes the numbers in the integration time points.Computation that generates random values from the specified discrete distribution and memoizes the values in the integration time points. minimummaximumminimummaximumminimummedianmaximummean deviationJthe mean of a normal distribution which this distribution is derived fromOthe deviation of a normal distribution which this distribution is derived from#the mean (a reciprocal of the rate)$the scale (a reciprocal of the rate) the shapethe meanthe probabilitythe number of trialsshape scale (a reciprocal of the rate) shape (alpha) shape (beta)shapescale   #@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneC%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.CReturn 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 runDynamicsInStopTime $ sequence [a, b, c] Like ! but allows either setting a new + integral value, or integrating using the ( derivative directly within computation.)This function always uses Euler's method.*Return the first order exponential smooth.rTo create a loopback, you should use the recursive do-notation 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.rTo create a loopback, you should use the recursive do-notation 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 0 function without specifying the initial value.)Return the n'th order exponential smooth.The result is not discrete in that sense that it may change within the integration time interval depending on the integration method used. Probably, you should apply the  function to the result if you want to achieve an effect when 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 0 function without specifying the initial value.)Return the first order exponential delay.rTo create a loopback, you should use the recursive do-notation with help of which the function itself is defined: Jdelay1I 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 0 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 0 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 0 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 SRetun the sum for the difference equation. It is like an integral returned by the B function, only now the difference is used instead of derivative.IAs usual, to create a loopback, you should use the recursive do-notation.Like ! but allows either setting a new  sum value, or adding the  difference.Lookup x in a table of pairs (x, y) using linear interpolation.Lookup x in a table of pairs (x, y) using stepwise function.6Return the delayed value using the specified lag time.Return the delayed value using the specified lag time and initial value. Because of the latter, it allows creating a loop back.Return 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 Return the Net Present Value End of period (NPVE) of the stream computed 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 UComputation that returns 0 until the step time and then returns the specified height.~Computation that returns 1, starting at the time start, and lasting for the interval width; 0 is returned at all other times.Computation that returns 1, starting at the time start, and lasting for the interval width and then repeats this pattern with the specified period; 0 is returned at all other times.}Computation that returns 0 until the specified time start and then slopes upward until the end time and then holds constant.)the derivativethe initial value the integraleither set a new  integral value, or use a  derivativethe initial valuethe value to smooth over timetimethe initial value"the first order exponential smooththe value to smooth over timetime"the first order exponential smooththe value to smooth over timetimethe initial value"the third order exponential smooththe value to smooth over timetime"the third order exponential smooththe value to smooth over timetime the orderthe initial value!the n'th order exponential smooththe value to smooth over timetime the order!the n'th order exponential smooththe value to conservetimethe initial value!the first order exponential delaythe value to conservetime!the first order exponential delaythe value to conservetimethe initial value!the third order exponential delaythe value to conservetime!the third order exponential delaythe value to conservetime the orderthe initial value the n'th order exponential delaythe value to conservetime the order the n'th order exponential delaythe value to forecastthe average timethe time horizon the forecast+the value for which the trend is calculatedthe average timethe initial valuethe fractional change ratethe differencethe initial valuethe sumeither set the  value for the sum, or add the  difference to the sumthe initial valuethe sumthe value to delay the lag timethe delayed valuethe value to delay the lag timethe initial valuethe delayed value the streamthe discount ratethe initial valuefactorthe Net Present Value (NPV) the streamthe discount ratethe initial valuefactor the Net Present Value End (NPVE) the height the step timethe time startthe interval widththe time startthe interval widththe time periodthe slope parameterthe time start the end time%%) @Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone$@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneEComputation that generates a new random number distributed uniformly.MComputation that generates a new random integer number distributed uniformly.PComputation that generates a new random number from the triangular distribution.DComputation that generates a new random number distributed normally.OComputation that generates a new random number from the lognormal distribution.oComputation that returns a new exponential random number with the specified mean (the reciprocal of the rate).}Computation that returns a new Erlang random number with the specified scale (the reciprocal of the rate) and integer shape.MComputation that returns a new Poisson random number with the specified mean.aComputation that returns a new binomial random number with the specified probability and trials.Computation that returns _ in case of success.Computation that returns ` in case of success.IComputation that returns a new random number from the Gamma distribution.HComputation that returns a new random number from the Beta distribution.KComputation that returns a new random number from the Weibull distribution.UComputation that returns a new random value from the specified discrete distribution.minimummaximumminimummaximumminimummedianmaximummean deviationJthe mean of a normal distribution which this distribution is derived fromOthe deviation of a normal distribution which this distribution is derived from%the mean (the reciprocal of the rate)&the scale (the reciprocal of the rate) the shapethe meanthe probabilitythe number of trialsthe probability of the successthe probability of the success the shape$the scale (a reciprocal of the rate)the shape (alpha)the shape (beta)shapescale%@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneBHold the process for a random time interval distributed uniformly.BHold the process for a random time interval distributed uniformly.BHold the process for a random time interval distributed uniformly.BHold the process for a random time interval distributed uniformly.OHold the process for a random time interval having the triangular distribution.OHold the process for a random time interval having the triangular distribution.AHold the process for a random time interval distributed normally.AHold the process for a random time interval distributed normally.NHold the process for a random time interval having the lognormal distribution. NHold the process for a random time interval having the lognormal distribution. |Hold the process for a random time interval distributed exponentially with the specified mean (the reciprocal of the rate). |Hold the process for a random time interval distributed exponentially with the specified mean (the reciprocal of the rate). Hold the process for a random time interval having the Erlang distribution with the specified scale (the reciprocal of the rate) and shape parameters. Hold the process for a random time interval having the Erlang distribution with the specified scale (the reciprocal of the rate) and shape parameters.eHold the process for a random time interval having the Poisson distribution with the specified mean.eHold the process for a random time interval having the Poisson distribution with the specified mean.xHold the process for a random time interval having the binomial distribution with the specified probability and trials.xHold the process for a random time interval having the binomial distribution with the specified probability and trials.nHold the process for a random time interval having the Gamma distribution with the specified shape and scale.nHold the process for a random time interval having the Gamma distribution with the specified shape and scale.Hold the process for a random time interval having the Beta distribution with the specified shape parameters (alpha and beta).Hold the process for a random time interval having the Beta distribution with the specified shape parameters (alpha and beta).pHold the process for a random time interval having the Weibull distribution with the specified shape and scale.pHold the process for a random time interval having the Weibull distribution with the specified shape and scale.WHold the process for a random time interval having the specified discrete distribution.WHold the process for a random time interval having the specified discrete distribution.the minimum time intervalthe maximum time intervalKa computation of the time interval for which the process was actually heldthe minimum time intervalthe maximum time intervalthe minimum time intervalthe maximum time intervalKa computation of the time interval for which the process was actually heldthe minimum time intervalthe maximum time intervalthe minimum time intervala median of the time intervalthe maximum time intervalKa computation of the time interval for which the process was actually heldthe minimum time intervala median of the time intervalthe maximum time intervalthe mean time intervalthe time interval deviationKa computation of the time interval for which the process was actually heldthe mean time intervalthe time interval deviationKthe mean for a normal distribution which this distribution is derived fromPthe deviation for a normal distribution which this distribution is derived fromKa computation of the time interval for which the process was actually held Kthe mean for a normal distribution which this distribution is derived fromPthe deviation for a normal distribution which this distribution is derived from 3the mean time interval (the reciprocal of the rate)Ka computation of the time interval for which the process was actually held 3the mean time interval (the reciprocal of the rate) &the scale (the reciprocal of the rate) the shapeKa computation of the time interval for which the process was actually held &the scale (the reciprocal of the rate) the shapethe mean time intervalKa computation of the time interval for which the process was actually heldthe mean time intervalthe probabilitythe number of trialsKa computation of the time interval for which the process was actually heldthe probabilitythe number of trials the shape$the scale (a reciprocal of the rate)Ka computation of the time interval for which the process was actually held the shape$the scale (a reciprocal of the rate)the shape (alpha)the shape (beta)Ka computation of the time interval for which the process was actually heldthe shape (alpha)the shape (beta) the shape the scaleKa computation of the time interval for which the process was actually held the shape the scale)the discrete probability density functionKa computation of the time interval for which the process was actually held)the discrete probability density function               &@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone4Represents an accumulator for the timing statistics."Return the accumulated statistics.HStart gathering the timing statistics from the current simulation time. '@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneCOIt allows representing an analogous circuit as an opposite to the digital one.This is a transform of one time varying function to another usually specified in the integration time points and then interpolated in other time points with help of one of the memoization functions like .Run the transform. 3A transform that returns the current modeling time.!GReturn a delayed transform by the specified lag time and initial value.This is actually the  function wrapped in the  type. "[Return a transform that maps the derivative to an integral by the specified initial value.This is actually the  function wrapped in the  type. #Like "! but allows either setting a new 9 value of the integral, or updating it by the specified  derivative.$UReturn a transform that maps the difference to a sum by the specified initial value.This is actually the  function wrapped in the  type. %Like $! but allows either setting a new 4 value of the sum, or updating it by the specified  difference.  ! the lag timethe initial valuethe delayed transform"the initial value!map the derivative to an integral#the initial valuemap either a new  value or the  derivative to an integral$the initial valuemap the difference to a sum%the initial valuemap either a new  value or the  difference to a sum  !"#$% ! "#$%  !"#$%(@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone&A transform that memoizes and order the computation in the integration time points using the interpolation that knows of the Runge-Kutta method. The values are calculated sequentially starting from .'_A transform that memoizes and order the computation in the integration time points using the 1 interpolation. It consumes less memory than the & computation but it is not aware of the Runge-Kutta method. There is a subtle difference when we request for values in the intermediate time points that are used by this method to integrate. In general case you should prefer the ' computation above &.(A transform that iterates sequentially the dynamic process with side effects in the integration time points. It is equivalent to the 'V computation but significantly more efficient, for the internal array is not created.&'(&'(&'(&'()@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone)+A transform that returns the initial value.*LA transform that discretizes the computation in the integration time points.+dA tranform that interpolates the computation based on the integration time points only. Unlike the *c computation it knows about the intermediate time points that are used in the Runge-Kutta method.,Like the standard  function but applied to values in the integration time points. The accumulator values are transformed according to the second argument, which should be either ' or its unboxed version.-Like the standard  function but applied to values in the integration time points. The accumulator values are transformed according to the third argument, which should be either ' or its unboxed version.)*+,-)*+,-)*+-,)*+,-*@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone3.A transform that memoizes and order the computation in the integration time points using the interpolation that knows of the Runge-Kutta method. The values are calculated sequentially starting from ./_A transform that memoizes and order the computation in the integration time points using the 1 interpolation. It consumes less memory than the . computation but it is not aware of the Runge-Kutta method. There is a subtle difference when we request for values in the intermediate time points that are used by this method to integrate. In general case you should prefer the / computation above ..././././@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneabcdefbfedca+@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone20KRepresents an infinite stream of data in time, some kind of the cons cell.2Run the stream.3mCreate a stream that will use the specified process identifier. It can be useful to refer to the underlying iV computation which can be passivated, interrupted, canceled and so on. See also the  function for more details.4[Memoize the stream so that it would always return the same data within the simulation run.50Zip two streams trying to get data sequentially.6aZip two streams trying to get data as soon as possible, launching the sub-processes in parallel.72Zip three streams trying to get data sequentially.8cZip three streams trying to get data as soon as possible, launching the sub-processes in parallel.9Unzip the stream.:gTo form each new portion of data for the output stream, read data sequentially from the input streams.This is a generalization of 5.;fTo form each new portion of data for the output stream, read data from the input streams in parallel.This is a generalization of 6.<=Return a stream of values generated by the specified process.=0Map the stream according the specified function.>Compose the stream.?Sequential application.@Sequential application.AFFilter only those data values that satisfy to the specified predicate.BFFilter only those data values that satisfy to the specified predicate.CThe stream of  values.DThe stream of  values.E Replace the  values.F Replace the  values.GPartition the stream of  values into two streams.HWSplit the input stream into the specified number of output streams after applying the , strategy for enqueuing the output requests.ICSplit the input stream into the specified number of output streams.JIf you don't know what the strategy to apply, then you probably need the  strategy, or function H that does namely this.JUSplit the input stream into a list of output streams using the specified priorities.K+Concatenate the input streams applying the + strategy and producing one output stream.L:Concatenate the input streams producing one output stream.JIf you don't know what the strategy to apply, then you probably need the  strategy, or function K that does namely this.MCConcatenate the input priority streams producing one output stream.NMerge two streams applying the ' strategy for enqueuing the input data.OMerge two streams.JIf you don't know what the strategy to apply, then you probably need the  strategy, or function N that does namely this.PMerge two priority streams.Q(An empty stream that never returns data.RConsume the stream. It returns a process that infinitely reads data from the stream and then redirects them to the provided function. It is useful for modeling the process of enqueueing data in the queue from the input stream.SSink the stream. It returns a process that infinitely reads data from the stream. The resulting computation can be a moving force to simulate the whole system of the interconnected streams and processors.TPrefetch the input stream requesting for one more data item in advance while the last received item is not yet fully processed in the chain of streams, usually by the processors.You can think of this as the prefetched stream could place its latest data item in some temporary space for later use, which is very useful for modeling a sequence of separate and independent work places.U<Return a stream of values triggered by the specified signal.Since the time at which the values of the stream are requested for may differ from the time at which the signal is triggered, it can be useful to apply the Fd function to add the information about the time points at which the signal was actually received.The point is that the 0! is requested outside, while the (g is triggered inside. They are different by nature. The former is passive, while the latter is active.The resulting stream may be a root of space leak as it uses an internal queue to store the values received from the signal. The oldest value is dequeued each time we request the stream and it is returned within the computation.ECancel the stream's process to unsubscribe from the specified signal.VReturn a computation of the signal that triggers values from the specified stream, each time the next value of the stream is received within the underlying i computation.GCancel the returned process to stop reading from the specified stream. WTransform a stream so that the resulting stream returns a sequence of arrivals saving the information about the time points at which the original stream items were received by demand.X?Delay the stream by one step using the specified initial value.YEReturn a stream consisting of exactly one element and inifinite tail.ZWRemoves one level of the computation, projecting its bound stream into the outer level.[pTakes the next stream from the list after the current stream fails because of cancelling the underlying process.\8Return the prefix of the stream of the specified length.]OReturn the longest prefix of the stream of elements that satisfy the predicate.^QReturn the longest prefix of the stream of elements that satisfy the computation._CReturn the suffix of the stream after the specified first elements.`<Return the suffix of the stream of elements remaining after ].a<Return the suffix of the stream of elements remaining after ^.b9Show the debug messages with the current simulation time.70123456789:;<=>?@ABCDEFGHI6the strategy applied for enqueuing the output requeststhe number of output streamsthe input streamthe splitted output streamsJ6the strategy applied for enqueuing the output requeststhe streams of prioritiesthe input streamthe splitted output streamsKL1the strategy applied for enqueuing the input datathe input streamthe combined output streamM1the strategy applied for enqueuing the input datathe input streamthe combined output streamNO1the strategy applied for enqueuing the input datathe fist input streamthe second input streamthe output combined streamP1the strategy applied for enqueuing the input datathe fist input streamthe second input streamthe output combined streamQRSTUVWXYZ[\]^_`abthe request messagethe response messagea stream 30123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab3012QNOPKLMHIJ3TXW456789:;RS<=>?@AB\]^_`aYZ[UVCDEFGb50123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab ,@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNonec*Represents a processor of simulation data.eRun the processor.f6A processor that never finishes its work producing an Q.gCreate a simple processor by the specified handling function that runs the discontinuous process for each input value to get the output.hEAccumulator that outputs a value determined by the supplied function.iJInvolve the computation with side effect when processing a stream of data.jpCreate a processor that will use the specified process identifier. It can be useful to refer to the underlying iV computation which can be passivated, interrupted, canceled and so on. See also the  function for more details.kvLaunches the specified processors in parallel consuming the same input stream and producing a combined output stream.UIf you don't know what the enqueue strategies to apply, then you will probably need ' for the both parameters, or function o that does namely this.lXLaunches the specified processors in parallel using priorities for combining the output.mXLaunches the specified processors in parallel using priorities for consuming the intput.nqLaunches the specified processors in parallel using priorities for consuming the input and combining the output.oLaunches the processors in parallel consuming the same input stream and producing a combined output stream. This version applies the N strategy both for input and output, which suits the most part of uses cases.p/Launches the processors sequentially using the wO between them to model an autonomous work of each of the processors specified.qCreate a buffer processor, where the process from the first argument consumes the input stream but the stream passed in as the second argument and produced usually by some other process is returned as an output. This kind of processor is very useful for modeling the queues.rLike q but allows creating a loop when some items can be processed repeatedly. It is very useful for modeling the processors with queues and loop-backs.s=Return a processor with help of which we can model the queue.Although the function doesn't refer to the queue directly, its main use case is namely a processing of the queue. The first argument should be the enqueueing operation, while the second argument should be the opposite dequeueing operation.The reason is as follows. There are many possible combinations how the queues can be modeled. There is no sense to enumerate all them creating a separate function for each case. We can just use combinators to define exactly what we need.So, the queue can lose the input items if the queue is full, or the input process can suspend while the queue is full, or we can use priorities for enqueueing, storing and dequeueing the items in different combinations. There are so many use cases!There is a hope that this function along with other similar functions from this module is sufficient to cover the most important cases. Even if it is not sufficient then you can use a more generic function q which this function is based on. In case of need, you can even write your own function from scratch. It is quite easy actually.tLike s creates a queue processor but with a loop when some items can be processed and then added to the queue again. Also it allows specifying how two input streams of data can be merged.uLike t< creates a queue processor with a loop when some items can be processed and then added to the queue again. Only it sequentially merges two input streams of data: one stream that come from the external source and another stream of data returned by the loop. The first stream has a priority over the second one.vLike t creates a queue processor with a loop when some items can be processed and then added to the queue again. Only it runs two simultaneous processes to enqueue the input streams of data: one stream that come from the external source and another stream of data returned by the loop.wThis is a prefetch processor that requests for one more data item from the input in advance while the latest item is not yet fully processed in the chain of streams, usually by other processors.You can think of this as the prefetched processor could place its latest data item in some temporary space for later use, which is very useful for modeling a sequence of separate and independent work places.x6Convert the specified signal transform to a processor.dThe processor may return data with delay as the values are requested by demand. Consider using the Fl function to provide with the information about the time points at which the signal was actually triggered.The point is that the 0 used in the c# is requested outside, while the (h is triggered inside. They are different by nature. The former is passive, while the latter is active.HCancel the processor's process to unsubscribe from the signals provided.y7Convert the specified processor to a signal transform. dThe processor may return data with delay as the values are requested by demand. Consider using the Fl function to provide with the information about the time points at which the signal was actually triggered.The point is that the 0 used in the c# is requested outside, while the (g is triggered inside. They are different by nature. The former is passive, while the latter is active.ECancel the returned process to unsubscribe from the signal specified.zyA processor that adds the information about the time points at which the original stream items were received by demand.{WA processor that delays the input stream by one step using the specified initial value.|ZRemoves one level of the computation, projecting its bound processor into the outer level.}vTakes the next processor from the list after the current processor fails because of cancelling the underlying process.~9Show the debug messages with the current simulation time.!cdefghijk1the strategy applied for enqueuing the input data2the strategy applied for enqueuing the output datathe processors to parallelizethe parallelized processorl1the strategy applied for enqueuing the input data2the strategy applied for enqueuing the output datathe processors to parallelizethe parallelized processorm1the strategy applied for enqueuing the input data2the strategy applied for enqueuing the output dataBthe streams of input priorities and the processors to parallelizethe parallelized processorn1the strategy applied for enqueuing the input data2the strategy applied for enqueuing the output dataBthe streams of input priorities and the processors to parallelizethe parallelized processoropq(a separate process to consume the input the resulting stream of datar.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 e7 should be processed in the loop (this is a condition)5process in the loop and then return a value of type c) to the input again (this is a loop body)sienqueue the input item and wait while the queue is full if required so that there were no hanging itemsdequeue an output itemthe buffering processort,merge two streams: the input values of type a and the values of type d returned by the loopienqueue 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 f7 should be processed in the loop (this is a condition)5process in the loop and then return a value of type d) to the queue again (this is a loop body)the buffering processoruienqueue 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 e7 should be processed in the loop (this is a condition)5process in the loop and then return a value of type a) to the queue again (this is a loop body)the buffering processorvienqueue 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 e7 should be processed in the loop (this is a condition)5process in the loop and then return a value of type a) to the queue again (this is a loop body)the buffering processorwxyz{|}~the request messagethe response message a processor    cdefghijklmnopqrstuvwxyz{|}~cdefghijw{qrstuvpoklmnz|}xy~cdefghijklmnopqrstuvwxyz{|}~    -@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone hWhen processing every input element, hold the process for a random time interval distributed uniformly.hWhen processing every input element, hold the process for a random time interval distributed uniformly.uWhen processing every input element, hold the process for a random time interval having the triangular distribution.gWhen processing every input element, hold the process for a random time interval distributed normally.tWhen processing every input element, hold the process for a random time interval having the lognormal distribution.When processing every input element, hold the process for a random time interval distributed exponentially with the specified mean (the reciprocal of the rate).When processing every input element, hold the process for a random time interval having the Erlang distribution with the specified scale (the reciprocal of the rate) and shape parameters.When processing every input element, hold the process for a random time interval having the Poisson distribution with the specified mean.When processing every input element, hold the process for a random time interval having the binomial distribution with the specified probability and trials.When processing every input element, hold the process for a random time interval having the Gamma distribution with the specified shape and scale.When processing every input element, hold the process for a random time interval having the Beta distribution with the specified shape parameters (alpha and beta).When processing every input element, hold the process for a random time interval having the Weibull distribution with the specified shape and scale.}When processing every input element, hold the process for a random time interval having the specified discrete distribution. the minimum time intervalthe maximum time intervalthe minimum time intervalthe maximum time intervalthe minimum time intervalthe median of the time intervalthe maximum time intervalthe mean time intervalthe time interval deviationKthe mean for a normal distribution which this distribution is derived fromPthe deviation for a normal distribution which this distribution is derived from3the mean time interval (the reciprocal of the rate)&the scale (the reciprocal of the rate) the shapethe mean time intervalthe probabilitythe number of trials the shape$the scale (a reciprocal of the rate) shape (alpha) shape (beta)shapescale)the discrete probability density function   .@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneRepresents the Round-Robbin processor that tries to perform the task within the specified timeout. If the task times out, then it is canceled and returned to the processor again; otherwise, the successful result is redirected to output.Like  but allows specifying the process identifiers which must be unique for every new attemp to perform the task even if the task is the same./@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneFIt 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.%Whether the process can be preempted.2The counted total time spent in awating the input.IThe counted total time spent to process the input and prepare the output.7The counted total time spent for delivering the output.MThe counted total time spent being preempted and waiting for the proceeding. 8The statistics for the time spent in awaiting the input.NThe statistics for the time spent to process the input and prepare the output.<The statistics for the time spent for delivering the output.2The statistics for the time spent being preempted.@A signal raised when the server recieves a new input to process.,A signal raised when the task was preempted.PA signal raised when the task was proceeded after it had been preempted earlier.XA signal raised when the input is processed and the output is prepared for deliverying.8A signal raised when the server has supplied the output.,Create a new server that can provide output b by input a.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.,Create a new server that can provide output b by input a starting from state s.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.8Create a new preemptible server that can provide output b by input a.8Create a new preemptible server that can provide output b by input a starting from state s.,Return a processor for the specified server.The processor updates the internal state of the server. The usual case is when the processor is applied only once in a chain of data processing. Otherwise; every time the processor is used, the state of the server changes. Sometimes it can be indeed useful if you want to aggregate the statistics for different servers simultaneously, but it would be more preferable to avoid this._If 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 whole, where the first server will take a new task only after the last server 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.XTo model a sequence of the server processors working independently, you should use the p; function which separates the processors with help of the w< that plays a role of a small one-place buffer in that case.The queue processors usually have the prefetching capabilities per se, where the items are already stored in the queue. Therefore, the server processor should not be prefetched if it is connected directly to the queue processor. ?Process the input with ability to handle a possible preemption.'Return the current state of the server. See also  and .Signal when the  property value has changed.Signal when the  property value has changed.RReturn 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.MReturn 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.]Return 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.mReturn the counted total time spent by the server while it was preempted waiting for the further proceeding.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.VReturn 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.QReturn 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.bReturn 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.qReturn the statistics of the time spent by the server while it was preempted waiting for the further proceeding.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.wIt returns the factor changing from 0 to 1, which estimates how often the server was awaiting for the next input task.This factor is calculated as n totalInputWaitTime / (totalInputWaitTime + totalProcessingTime + totalOutputWaitTime + totalPreemptionTime) As 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.|It returns the factor changing from 0 to 1, which estimates how often the server was busy with direct processing its tasks.This factor is calculated as o totalProcessingTime / (totalInputWaitTime + totalProcessingTime + totalOutputWaitTime + totalPreemptionTime) As 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.It returns the factor changing from 0 to 1, which estimates how often the server was locked trying to deliver the output after the task is finished.This factor is calculated as o totalOutputWaitTime / (totalInputWaitTime + totalProcessingTime + totalOutputWaitTime + totalPreemptionTime) As 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.It returns the factor changing from 0 to 1, which estimates how often the server was preempted waiting for the further proceeding.This factor is calculated as o totalPreemptionTime / (totalInputWaitTime + totalProcessingTime + totalOutputWaitTime + totalPreemptionTime) As 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.1Raised when the server receives a new input task..Raised when the task processing was preempted.SRaised when the task processing was proceeded after it had been preempeted earlier.3Raised when the server has just processed the task.5Raised when the server has just delivered the output.3Signal whenever any property of the server changes.oReturn the summary for the server with desciption of its properties and activities using the specified indent.G!(provide an output by the specified inputEprovide a new state and output by the specified old state and inputthe initial state+whether the server process can be preempted(provide an output by the specified input+whether the server process can be preemptedEprovide a new state and output by the specified old state and inputthe initial state 565! 0@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneCreate a new server that holds the process for a random time interval distributed uniformly, when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval distributed uniformly, when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval having the triangular distribution, when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval distributed normally, when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval having the lognormal distribution, when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval distributed exponentially with the specified mean (the reciprocal of the rate), when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval having the Erlang distribution with the specified scale (the reciprocal of the rate) and shape parameters, when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval having the Poisson distribution with the specified mean, when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval having the binomial distribution with the specified probability and trials, when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval having the Gamma distribution with the specified shape and scale, when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval having the Beta distribution with the specified shape parameters (alpha and beta), when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval having the Weibull distribution with the specified shape and scale, when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval having the specified discrete distribution, when processing every input element.By default, it is assumed that the server process cannot be preempted, because the handling of possible task preemption is rather costly operation.Create a new server that holds the process for a random time interval distributed uniformly, when processing every input element.Create a new server that holds the process for a random time interval distributed uniformly, when processing every input element.Create a new server that holds the process for a random time interval having the triangular distribution, when processing every input element.Create a new server that holds the process for a random time interval distributed normally, when processing every input element.Create a new server that holds the process for a random time interval having the lognormal distribution, when processing every input element.Create a new server that holds the process for a random time interval distributed exponentially with the specified mean (the reciprocal of the rate), when processing every input element.Create a new server that holds the process for a random time interval having the Erlang distribution with the specified scale (the reciprocal of the rate) and shape parameters, when processing every input element.Create a new server that holds the process for a random time interval having the Poisson distribution with the specified mean, when processing every input element.Create a new server that holds the process for a random time interval having the binomial distribution with the specified probability and trials, when processing every input element.Create a new server that holds the process for a random time interval having the Gamma distribution with the specified shape and scale, when processing every input element.Create a new server that holds the process for a random time interval having the Beta distribution with the specified shape parameters (alpha and beta), when processing every input element.Create a new server that holds the process for a random time interval having the Weibull distribution with the specified shape and scale, when processing every input element.Create a new server that holds the process for a random time interval having the specified discrete distribution, when processing every input element.the minimum time intervalthe maximum time intervalthe minimum time intervalthe maximum time intervalthe minimum time intervalthe median of the time intervalthe maximum time intervalthe mean time intervalthe time interval deviationJthe mean of a normal distribution which this distribution is derived fromOthe deviation of a normal distribution which this distribution is derived from3the mean time interval (the reciprocal of the rate)&the scale (the reciprocal of the rate) the shapethe mean time intervalthe probabilitythe number of trials the shape$the scale (a reciprocal of the rate) shape (alpha) shape (beta)shapescale)the discrete probability density function+whether the server process can be preemptedthe minimum time intervalthe maximum time interval+whether the server process can be preemptedthe minimum time intervalthe maximum time interval+whether the server process can be preemptedthe minimum time intervalthe median of the time intervalthe maximum time interval+whether the server process can be preemptedthe mean time intervalthe time interval deviation+whether the server process can be preemptedJthe mean of a normal distribution which this distribution is derived fromOthe deviation of a normal distribution which this distribution is derived from+whether the server process can be preempted3the mean time interval (the reciprocal of the rate)+whether the server process can be preempted&the scale (the reciprocal of the rate) the shape+whether the server process can be preemptedthe mean time interval+whether the server process can be preemptedthe probabilitythe number of trials+whether the server process can be preempted the shape$the scale (a reciprocal of the rate)+whether the server process can be preempted shape (alpha) shape (beta)+whether the server process can be preemptedshapescale+whether the server process can be preempted)the discrete probability density function1@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneC Represents a circuit synchronized with the event queue. Besides, it allows creating the recursive links with help of the proc-notation.Run the circuit.0Get a signal transform by the specified circuit.%Transform the circuit to a processor.|Create a simple circuit by the specified handling function that runs the computation for each input value to get an output.EAccumulator that outputs a value determined by the supplied function.^A 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.1A circuit that returns the current modeling time.Like + but processes only the represented events.Like "+ but processes only the represented events.fFilter the circuit, calculating only those parts of the circuit that satisfy the specified predicate.Filter the circuit within the ` computation, calculating only those parts of the circuit that satisfy the specified predicate.&The source of events that never occur.6An approximation of the integral using Euler's method.UThis function can be rather inaccurate as it depends on the time points at wich the w computation is actuated. Also Euler's method per se is not most accurate, although simple enough for implementation.Consider using the  function whenever possible. That function can integrate with help of the Runge-Kutta method by 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 unlike the former. The latter consumes less memory but at the cost of inaccuracy and relatively more slow simulation, had we requested the integral in the same time points.Regarding the recursive equations, the both functions allow defining them but whithin different computations (either with help of the recursive do-notation or the proc-notation).Like ! but allows either setting a new  integral value, or using the / derivative when integrating by Euler's method.?A sum of differences starting from the specified initial value.!Consider using the more accurate v function whener possible as it is calculated in every integration time point specified by specs passed in to every , when running the model.At the same time, the L function has no mutable state and it consumes less memory than the former.Regarding the recursive equations, the both functions allow defining them but whithin different computations (either with help of the recursive do-notation or the proc-notation).Like ! but allows either setting a new 6 value for the sum, or updating it by specifying the  difference.Approximate the circuit as a transform of time varying function, calculating the values in the integration time points and then interpolating in all other time points. The resulting transform computation is synchronized with the event queue. pThis procedure consumes memory as the underlying memoization allocates an array to store the calculated values.#1Iterate the circuit in the specified time points.$Iterate the circuit in the specified time points returning a task which completes after the final output of the circuit is received.3Iterate the circuit in the integration time points.1Iterate the circuit in the specified time points.Iterate the circuit in the integration time points returning a task which completes after the final output of the circuit is received.Iterate the circuit in the specified time points returning a task which completes after the final output of the circuit is received.%]Iterate the circuit in the specified time points, interrupting the iteration immediately if > is returned within the  computation._Iterate the circuit in the integration time points, interrupting the iteration immediately if > is returned within the  computation.]Iterate the circuit in the specified time points, interrupting the iteration immediately if > is returned within the  computation.&Iterate the circuit in the specified time points returning a task that computes the final output of the circuit either after all points are exhausted, or after the  result of type b< is received, which interrupts the computation immediately.Iterate the circuit in the integration time points returning a task that computes the final output of the circuit either after all points are exhausted, or after the  result of type b< is received, which interrupts the computation immediately.Iterate the circuit in the specified time points returning a task that computes the final output of the circuit either after all points are exhausted, or after the  result of type b< is received, which interrupts the computation immediately.9Show the debug messages with the current simulation time.%whether there is an event process the event if it presents@the resulting circuit that processes only the represented events process the event if it presentswhether there is an event@the resulting circuit that processes only the represented eventsthe initial value!map the derivative to an integralthe initial valuemap either a new  value or the  derivative to an integralthe initial valuemap the difference to a sumthe initial valuemap either a new  value or the  difference to a sum#$%&the request messagethe response message a circuit'()*##$%&'()*2@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone6Represents the net as an automaton working within the i computation. Run the net.#A net that never finishes its work.Create a simple net by the specified handling function that runs the discontinuous process for each input value to get an output.EAccumulator that outputs a value determined by the supplied function.CInvolve the computation with side effect when processing the input.jCreate a net that will use the specified process identifier. It can be useful to refer to the underlying iV computation which can be passivated, interrupted, canceled and so on. See also the  function for more details.MTransform the net to an equivalent processor (a rather cheap transformation).HTransform the processor to a similar net (a more costly transformation).ZA 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.5Iterate infinitely using the specified initial value.9Iterate the net using the specified initial value until > is returned within the  computation.=Iterate the net using the specified initial value until the  result is returned within the  computation. 9Show the debug messages with the current simulation time. the request messagethe response messagea net+,-   +,-3@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone  hWhen processing every input element, hold the process for a random time interval distributed uniformly. hWhen processing every input element, hold the process for a random time interval distributed uniformly. uWhen processing every input element, hold the process for a random time interval having the triangular distribution. gWhen processing every input element, hold the process for a random time interval distributed normally.tWhen processing every input element, hold the process for a random time interval having the lognormal distribution.When processing every input element, hold the process for a random time interval distributed exponentially with the specified mean (the reciprocal of the rate).When processing every input element, hold the process for a random time interval having the Erlang distribution with the specified scale (the reciprocal of the rate) and shape parameters.When processing every input element, hold the process for a random time interval having the Poisson distribution with the specified mean.When processing every input element, hold the process for a random time interval having the binomial distribution with the specified probability and trials.When processing every input element, hold the process for a random time interval having the Gamma distribution with the specified shape and scale.When processing every input element, hold the process for a random time interval having the Beta distribution with the specified shape parameters (alpha and beta).When processing every input element, hold the process for a random time interval having the Weibull distribution with the specified shape and scale.}When processing every input element, hold the process for a random time interval having the specified discrete distribution.  the minimum time intervalthe maximum time interval the minimum time intervalthe maximum time interval the minimum time intervalthe median of the time intervalthe maximum time interval the mean time intervalthe time interval deviationJthe mean of a normal distribution which this distribution is derived fromOthe deviation of a normal distribution which this distribution is derived from3the mean time interval (the reciprocal of the rate)&the scale (the reciprocal of the rate) the shapethe mean time intervalthe probabilitythe number of trials the shape$the scale (a reciprocal of the rate) shape (alpha) shape (beta)shapescale)the discrete probability density function               @Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNonePAccumulates the statistics about that how long the arrived events are processed.KCreate a new timer that measures how long the arrived events are processed.LReturn the statistics about that how long the arrived events were processed.GReturn a signal raised when the the processing time statistics changes.GReturn a signal raised when the the processing time statistics changes.iReturn a processor that actually measures how much time has passed from the time of arriving the events. ./0  !  !./04@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneEReturn a sream of random events that arrive with the specified delay.=Create a new stream with random delays distributed uniformly.ECreate a new stream with integer random delays distributed uniformly. JCreate a new stream with random delays having the triangular distribution.!<Create a new stream with random delays distributed normally."ICreate a new stream with random delays having the lognormal distribution.#vReturn a new stream with random delays distibuted exponentially with the specified mean (the reciprocal of the rate).$Return a new stream with random delays having the Erlang distribution with the specified scale (the reciprocal of the rate) and shape parameters.%`Return a new stream with random delays having the Poisson distribution with the specified mean.&sReturn a new stream with random delays having the binomial distribution with the specified probability and trials.'gReturn a new stream with random delays having the Gamma distribution by the specified shape and scale.(xReturn a new stream with random delays having the Beta distribution by the specified shape parameters (alpha and beta).)iReturn a new stream with random delays having the Weibull distribution by the specified shape and scale.*RReturn a new stream with random delays having the specified discrete distribution..compute a pair of the delay and event of type aa stream of delayed eventsthe minimum delaythe maximum delay5the stream of random events with the delays generatedthe minimum delaythe maximum delay5the stream of random events with the delays generated the minimum delaythe median of the delaythe maximum delay5the stream of random events with the delays generated!the mean delaythe delay deviation5the stream of random events with the delays generated"Jthe mean of a normal distribution which this distribution is derived fromOthe deviation of a normal distribution which this distribution is derived from5the stream of random events with the delays generated#+the mean delay (the reciprocal of the rate)5the stream of random events with the delays generated$&the scale (the reciprocal of the rate) the shape5the stream of random events with the delays generated%the mean delay5the stream of random events with the delays generated&the probabilitythe number of trials5the stream of random events with the delays generated' the shape$the scale (a reciprocal of the rate)5the stream of random events with the delays generated(the shape (alpha)the shape (beta)5the stream of random events with the delays generated)shapescale5the stream of random events with the delays generated*)the discrete probability density function5the stream of random events with the delays generated !"#$%&'()* !"#$%&'()* !"#$%&'()*5@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone+Represents the agent state.,Return the corresponded agent.-Return the parent state or >..Represents an agent./xAdd to the state a timeout handler that will be actuated in the specified time period if the state will remain active.0Add to the state a timer handler that will be actuated in the specified time period and then repeated again many times, while the state remains active.1Create a new state.2Create a child state.3Create an agent.4!Return the selected active state.5lSelect the state. The activation and selection are repeated while there is the transition state defined by 8.67Set the activation computation for the specified state.79Set the deactivation computation for the specified state.8sSet the transition state which will be next and which is used only when selecting the state directly with help of 5o. If the state was activated intermediately, when selecting another state, then this computation is not used.10Trigger the signal when the agent state changes.9GReturn a signal that notifies about every change of the selected state.:GReturn a signal that notifies about every change of the selected state.$2345+6,-789:.;<=>?@AB/01234567819:CD+,-./0123456789:.+,-31249:5,-/06782543+6,-789:.;<=>?@AB/01234567819:CD6@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone9;Like " it models an activity that takes a and provides b having state sH. But unlike the former the activity is destined for simulation within  computation.<"The initial state of the activity.E"The current state of the activity.FProvide b by specified a.G#Whether the process is preemptible.H1The counted total time of utilising the activity.I2The counted total time when the activity was idle.J8The counted total time when the activity was preempted. K(The statistics for the utilisation time.L7The statistics for the time when the activity was idle.M<The statistics for the time when the activity was preempted.N6A signal raised when starting to utilise the activity.O4A signal raised when the activity has been utilised.P3A signal raised when the utilisation was preempted.QWA signal raised when the utilisation was proceeded after it had been preempted earlier.=.Create a new activity that can provide output b by input a.By default, it is assumed that the activity utilisation cannot be preempted, because the handling of possible task preemption is rather costly operation.>.Create a new activity that can provide output b by input a starting from state s.By default, it is assumed that the activity utilisation cannot be preempted, because the handling of possible task preemption is rather costly operation.?:Create a new preemptible activity that can provide output b by input a.@.Create a new activity that can provide output b by input a starting from state s.A8Return a network computation for the specified activity.The computation updates the internal state of the activity. The usual case is when the computation is applied only once in a chain of data processing. Otherwise; every time the computation is used, the state of the activity changes. Sometimes it can be indeed useful if you want to aggregate the statistics for different activities simultaneously, but it would be more preferable to avoid this.cIf you connect different activity computations returned by this function in a chain with help of $ or other category combinator then this chain will act as one whole, where the first activity will take a new task only after the last activity finishes its current task and requests for the next one from the previous activity in the chain. This is not always that thing you might need.R?Process the input with ability to handle a possible preemption.B)Return the current state of the activity. See also C and D.CSignal when the B property value has changed.DSignal when the B property value has changed.E=Return the counted total time when the activity was utilised.iThe value returned changes discretely and it is usually delayed relative to the current simulation time. See also F and G.FSignal when the E property value has changed.GSignal when the E property value has changed.H9Return the counted total time when the activity was idle.iThe value returned changes discretely and it is usually delayed relative to the current simulation time. See also I and J.ISignal when the H property value has changed.JSignal when the H property value has changed.KaReturn the counted total time when the activity was preemted waiting for the further proceeding.iThe value returned changes discretely and it is usually delayed relative to the current simulation time. See also L and M.LSignal when the K property value has changed.MSignal when the K property value has changed.NBReturn the statistics for the time when the activity was utilised.iThe value returned changes discretely and it is usually delayed relative to the current simulation time. See also O and P.OSignal when the N property value has changed.PSignal when the N property value has changed.Q>Return the statistics for the time when the activity was idle.iThe value returned changes discretely and it is usually delayed relative to the current simulation time. See also R and S.RSignal when the Q property value has changed.SSignal when the Q property value has changed.TgReturn the statistics for the time when the activity was preempted waiting for the further proceeding.iThe value returned changes discretely and it is usually delayed relative to the current simulation time. See also U and V.USignal when the T property value has changed.VSignal when the T property value has changed.WaIt returns the factor changing from 0 to 1, which estimates how often the activity was utilised.This factor is calculated as V totalUtilisationTime / (totalUtilisationTime + totalIdleTime + totalPreemptionTime) As before in this module, the value returned changes discretely and it is usually delayed relative to the current simulation time. See also X and Y.XSignal when the W property value has changed.YSignal when the W property value has changed.Z]It returns the factor changing from 0 to 1, which estimates how often the activity was idle.This factor is calculated as O totalIdleTime / (totalUtilisationTime + totalIdleTime + totalPreemptionTime) As 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 Z property value has changed.\Signal when the Z property value has changed.]It returns the factor changing from 0 to 1, which estimates how often the activity was preempted waiting for the further proceeding.This factor is calculated as V totalUtilisationTime / (totalUtilisationTime + totalIdleTime + totalPreemptionTime) As 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.`PRaised when starting to utilise the activity after a new input task is received.aORaised when the activity has been utilised after the current task is processed.b3Raised when the activity utilisation was preempted.cWRaised when the activity utilisation was proceeded after it had been preempted earlier.d5Signal whenever any property of the activity changes.ebReturn the summary for the activity with desciption of its properties using the specified indent.:;S<EFGHIJKLMNOPQ=(provide an output by the specified input>Eprovide a new state and output by the specified old state and inputthe initial state?%whether the activity can be preempted(provide an output by the specified input@%whether the activity can be preemptedEprovide a new state and output by the specified old state and inputthe initial stateARBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde+;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde,;<=>?@A<BEHKNQTWZ]eCDFGIJLMOPRSUVXY[\^_`abcd+;S<EFGHIJKLMNOPQ=>?@ARBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde7@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNonefCreate a new activity that holds the process for a random time interval distributed uniformly, when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.gCreate a new activity that holds the process for a random time interval distributed uniformly, when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.hCreate a new activity that holds the process for a random time interval having the triangular distribution, when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.iCreate a new activity that holds the process for a random time interval distributed normally, when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.jCreate a new activity that holds the process for a random time interval having the lognormal distribution, when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.kCreate a new activity that holds the process for a random time interval distributed exponentially with the specified mean (the reciprocal of the rate), when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.lCreate a new activity that holds the process for a random time interval having the Erlang distribution with the specified scale (the reciprocal of the rate) and shape parameters, when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.mCreate a new activity that holds the process for a random time interval having the Poisson distribution with the specified mean, when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.nCreate a new activity that holds the process for a random time interval having the binomial distribution with the specified probability and trials, when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.oCreate a new activity that holds the process for a random time interval having the Gamma distribution with the specified shape and scale, when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.pCreate a new activity that holds the process for a random time interval having the Beta distribution with the specified shape parameters (alpha and beta), when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.qCreate a new activity that holds the process for a random time interval having the Weibull distribution with the specified shape and scale, when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.rCreate a new activity that holds the process for a random time interval having the specified discrete distribution, when processing every input element.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.sCreate a new activity that holds the process for a random time interval distributed uniformly, when processing every input element.tCreate a new activity that holds the process for a random time interval distributed uniformly, when processing every input element.uCreate a new activity that holds the process for a random time interval having the triangular distribution, when processing every input element.vCreate a new activity that holds the process for a random time interval distributed normally, when processing every input element.wCreate a new activity that holds the process for a random time interval having the lognormal distribution, when processing every input element.xCreate a new activity that holds the process for a random time interval distributed exponentially with the specified mean (the reciprocal of the rate), when processing every input element.yCreate a new activity that holds the process for a random time interval having the Erlang distribution with the specified scale (the reciprocal of the rate) and shape parameters, when processing every input element.zCreate a new activity that holds the process for a random time interval having the Poisson distribution with the specified mean, when processing every input element.{Create a new activity that holds the process for a random time interval having the binomial distribution with the specified probability and trials, when processing every input element.|Create a new activity that holds the process for a random time interval having the Gamma distribution with the specified shape and scale, when processing every input element.}Create a new activity that holds the process for a random time interval having the Beta distribution with the specified shape parameters (alpha and beta), when processing every input element.~Create a new activity that holds the process for a random time interval having the Weibull distribution with the specified shape and scale, when processing every input element.Create a new activity that holds the process for a random time interval having the specified discrete distribution, when processing every input element.fthe minimum time intervalthe maximum time intervalgthe minimum time intervalthe maximum time intervalhthe minimum time intervalthe median of the time intervalthe maximum time intervalithe mean time intervalthe time interval deviationjJthe mean of a normal distribution which this distribution is derived fromOthe deviation of a normal distribution which this distribution is derived fromk3the mean time interval (the reciprocal of the rate)l&the scale (the reciprocal of the rate) the shapemthe mean time intervalnthe probabilitythe number of trialso the shape$the scale (a reciprocal of the rate)p shape (alpha) shape (beta)qshapescaler)the discrete probability density functions-whether the activity process can be preemptedthe minimum time intervalthe maximum time intervalt-whether the activity process can be preemptedthe minimum time intervalthe maximum time intervalu-whether the activity process can be preemptedthe minimum time intervalthe median of the time intervalthe maximum time intervalv-whether the activity process can be preemptedthe mean time intervalthe time interval deviationw-whether the activity process can be preemptedJthe mean of a normal distribution which this distribution is derived fromOthe deviation of a normal distribution which this distribution is derived fromx-whether the activity process can be preempted3the mean time interval (the reciprocal of the rate)y-whether the activity process can be preempted&the scale (the reciprocal of the rate) the shapez-whether the activity process can be preemptedthe mean time interval{-whether the activity process can be preemptedthe probabilitythe number of trials|-whether the activity process can be preempted the shape the scale}-whether the activity process can be preempted shape (alpha) shape (beta)~-whether the activity process can be preemptedshapescale-whether the activity process can be preempted)the discrete probability density functionfghijklmnopqrstuvwxyz{|}~fghijklmnopqrstuvwxyz{|}~fghijklmnopqrstuvwxyz{|}~8@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNonehThe result entity identifier.$A localised property or object name.An user defined description. Property . Property . Property . Property . Property . Property . Property . Property . Represents a . Property ]. Property Z. Property W. Property T. Property Q. Property N. Property K. Property H. Property E. Property B. Property <.Represents an ;. Property . Property . Property . Property . Property . Property . Property . Property . Property . Property . Property . Property . Property . Property . Represents a . Property .An . Property D. Property A. Property >. Property ;. Property 8. Property 7. Property 6. Property 5. Property 4. Property 1. Property .. Property +. Property (. Property %. Property ". Property . Property . Property  . Property . Property . Property . Property  . Property  . An infinite a. A finite  . Property <. Property ;.A 9 value. Property R. Property Q. Property P. Property O. Property N. Property M. Property e. Property F. Property D. Property K. Property J. Property I.A G value. Property @. Property ?.A = value. Property `. Property _. Property ]. Property \. Property [. Property Z. Property Y.A W value.5Describes a vector item with the specified subscript.Describes a vector.A  computation.EA description used for describing the results when generating output.3It localises the description of simulation results.*A locale to output the simulation results.Examples are: "ru",  "en" etc.The Russian locale.The English locale.3The Russian localisation of the simulation results.3The English localisation of the simulation results..Lookup a localisation by the specified locale.hhh _9@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone234:M1Represents a vector with the specified subscript.1Represents an array with the specified subscript./Represents 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.EReturn the signal triggered when data change if such a signal exists.IIt representes the predefined signals provided by every simulation model.4The signal triggered in the integration time points.'The signal triggered in the start time.&The signal triggered in the stop time.(It transforms the results of simulation.&It contains the results of simulation.?The sources of simulation results as a map of associated names.5The sources of simulation results as an ordered list.WWhether 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.7The signal is unknown, but the entity probably changes.There is no signal at all.'Represents the very simulation results.EA container of the simulation results such as queue, server or array.The container name.The container identifier.The container data. CWhether the container emits a signal when changing simulation data. fA parameterised value that actually represents a generalised result item that have no parametric type. The value name. The value identifier.&Simulation data supplied by the value.?Whether the value emits a signal when changing simulation data.2It separates the simulation results when printing.The separator text./The simulation results represented by a vector.The vector name.The vector identifier.)The results supplied by the vector items.4The subscript used as a suffix to create item names.A combined signal if present.,A short version of the vector, i.e. summary.6The object property containing the simulation results.The property short label.The property identifier.0The simulation results supplied by the property. BThe simulation results represented by an object having properties."The object name.#The object identifier.$The object type identifier.%The object properties.&A combined signal if present.'0A short version of the object, i.e. its summary.(:Represents a type class for actual representing the items.)The item name.*The item identifier.+ Whether the item emits a signal.,Return an expanded version of the item, for example, when the statistics item is exanded to an object having the corresponded properties for count, average, deviation, minimum, maximum and so on.-Return usually a short version of the item, i.e. its summary, but values of some data types such as statistics can be implicitly expanded to an object with the corresponded properties..-Try to return integer numbers in time points./7Try to return lists of integer numbers in time points. 02Try to return statistics based on integer numbers.19Try to return timing statistics based on integer numbers.2,Try to return double numbers in time points.36Try to return lists of double numbers in time points. 41Try to return statistics based on double numbers.59Try to return timing statistics based on integer numbers.64Try to return string representations in time points.74The simulation results represented by a single item.9Encapsulates the result source.:This is a separator text.;A vector-like structure.<An object-like source.='The source consisting of a single item.>2It associates the result sources with their names.?Represents a provider of the simulation results. It is usually something, or an array of something, or a list of such values which can be simulated to get data.@YReturn the source of simulation results by the specified name, description and provider. AXReturn the source of simulation results by the specified name, identifier and provider. B@A name used for indentifying the results when generating output.CbTry to return a version optimised for fast aggregation of the statistics based on integer numbers.DpTry to return a version optimised for fast aggregation of the statistics based on double floating point numbers.E&Return integer numbers in time points.F0Return lists of integer numbers in time points. G+Return statistics based on integer numbers.H[Return a version optimised for fast aggregation of the statistics based on integer numbers.I2Return timing statistics based on integer numbers.J%Return double numbers in time points.K/Return lists of double numbers in time points. L*Return statistics based on double numbers.MiReturn a version optimised for fast aggregation of the statistics based on double floating point numbers.N2Return timing statistics based on integer numbers.O-Return string representations in time points.PBCalculate the result vector signal and memoize it in a new vector.QCCalculate the result vector summary and memoize it in a new vector.TTransform the result value.R8Create a new property source by the specified container.S6Create a constant property by the specified container.T{Create by the specified container a property that changes in the integration time points, or it is supposed to be such one.U-Create a property by the specified container.VbCreate by the specified container a mapped property which is recomputed each time again and again.WNConvert the result value to a container with the specified object identifier. X(Convert the result container to a value.USConvert the timing statistics data to its normalised sampling-based representation.YDConstruct a new result signal by the specified optional pure signal.VFlatten the result source.WReturn the result source name.X`Expand the result source returning a more detailed version expanding the properties as possible.YReturn a summarised and usually more short version of the result source expanding the main properties or excluding auxiliary properties if required.Z&Return a signal emitted by the source.Z/Represent the result source as integer numbers.[8Represent the result source as lists of integer numbers.\CRepresent the result source as statistics based on integer numbers.]fRepresent the result source as statistics based on integer numbers and optimised for fast aggregation.^JRepresent the result source as timing statistics based on integer numbers._=Represent the result source as double floating point numbers.`FRepresent the result source as lists of double floating point numbers.aQRepresent the result source as statistics based on double floating point numbers.btRepresent the result source as statistics based on double floating point numbers and optimised for fast aggregation.cXRepresent the result source as timing statistics based on double floating point numbers.d-Represent the result source as string values.eACreate the predefined signals provided by every simulation model.fPrepare the simulation results.g)Represent the results as integer numbers.h2Represent the results as lists of integer numbers.i=Represent the results as statistics based on integer numbers.j`Represent the results as statistics based on integer numbers and optimised for fast aggregation.kDRepresent the results as timing statistics based on integer numbers.l7Represent the results as double floating point numbers.m@Represent the results as lists of double floating point numbers.nKRepresent the results as statistics based on double floating point numbers.onRepresent the results as statistics based on double floating point numbers and optimised for fast aggregation.pRRepresent the results as timing statistics based on double floating point numbers.q'Represent the results as string values.r1Return a signal emitted by the specified results.sReturn an expanded version of the simulation results expanding the properties as possible, which takes place for expanding statistics to show the count, average, deviation, minimum, maximum etc. as separate values.tReturn a short version of the simulation results, i.e. their summary, expanding the main properties or excluding auxiliary properties if required.uTake a result by its name.v}Take 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 w function.wTake a result from the object with the specified identifier. It can identify an item, object property, the object iself, vector or its elements.x=Take a result from the vector by the specified integer index.y@Take a result from the vector by the specified string subscript.z@Compose the results using the specified transformation function.[MConcatenate the results using the specified list of transformation functions.\@Append the results using the specified transformation functions.{Return a pure signal as a result of combination of the predefined signals with the specified result signal usually provided by the sources.The signal returned is triggered when the source signal is triggered. The pure signal is also triggered in the integration time points if the source signal is unknown or it was combined with any unknown signal.|LReturn a new result value by the specified name, identifier and computation.],Return a source by the specified statistics.^/Return the summary by the specified statistics._3Return a source by the specified timing statistics.`6Return the summary by the specified timing statistics.a)Return a source by the specified counter.b)Return a source by the specified counter.c)Return a source by the specified counter.d)Return a source by the specified counter.e.Return a source by the specified finite queue.f1Return the summary by the specified finite queue.g0Return a source by the specified infinite queue.h3Return the summary by the specified infinite queue.i/Return a source by the specified arrival timer.j2Return the summary by the specified arrival timer.k(Return a source by the specified server.l+Return the summary by the specified server.m*Return a source by the specified activity.n+Return a summary by the specified activity.o*Return a source by the specified resource.p+Return a summary by the specified resource.q*Return a source by the specified resource.r+Return a summary by the specified resource.}/Return an arbitrary text as a separator source.~'Return the source of the modeling time.sMake an integer subscriptt      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQTR the containerthe property labelthe property identifier)get the specified data from the container&get the data signal from the containerS the containerthe property labelthe property identifier)get the specified data from the containerT the containerthe property labelthe property identifier)get the specified data from the containerU the containerthe property labelthe property identifier)get the specified data from the container*get a signal triggered when changing data.V the containerthe property labelthe property identifierrecompute the specified dataWXUYVWXYZZ[\]^_`abcdefghijklmnopqrstuvwxyz[\{|the result namethe result identifierthe result computation]the statistics^the statistics_the statistics`the statisticsa the counterb the counterc the counterd the counterethe queue containerfthe queue containergthe queue containerhthe queue containerithe arrival timer containerjthe arrival timer containerkthe server containerlthe server containermthe activity containernthe activity containerothe resource containerpthe resource containerqthe resource containerrthe resource container}~suvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~B?@Afstuvwxy    ghijklmnopqer{>9=<;:78()*+,-./0123456CDEFGHIJKLMNO !"#$%&'PQ RSTUVWXY}~Z[\]^_`abcdz|t      !"#$%&'()*+,-./0123456789=<;:>?@ABCDEFGHIJKLMNOPQTRSTUVWXUYVWXYZZ[\]^_`abcdefghijklmnopqrstuvwxyz[\{|]^_`abcdefghijklmnopqr}~suvwxyz{|}~:@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone&BThis is a function that prints the simulation results within the / computation synchronized with the event queue.AThis is a function that shows the simulation results within the / computation synchronized with the event queue.hPrint a localised text representation of the results by the specified source and with the given indent.[Print an indented and labelled text representation of the results by the specified source.hPrint a localised text representation of the results by the specified source and with the given indent.MPrint a localised text representation of the results by the specified source.MPrint a localised text representation of the results by the specified source.NPrint in Russian a text representation of the results by the specified source.NPrint in English a text representation of the results by the specified source.NPrint in Russian a text representation of the results by the specified source.NPrint in English a text representation of the results by the specified source.gShow a localised text representation of the results by the specified source and with the given indent.YShow an indented and labelled text representation of the results by the specified source.LShow a localised text representation of the results by the specified source.MShow in Russian a text representation of the results by the specified source.MShow 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.3Print 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.|It may consume much memory, for we have to traverse all the integration points to create the resulting function within the  computation.8Show the simulation results in the specified time point.9Show the simulation results in the specified time points.zIt may consume much memory, for we have to traverse all the specified points to create the resulting function within the  computation.@Run the simulation and then print the results in the start time.@Run the simulation and then print the results in the final time.MRun the simulation and then print the results in the integration time points.JRun the simulation and then print the results in the specified time point.KRun 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.LRun the simulation and then show the results in the integration time points.|It may consume much memory, for we have to traverse all the integration points to create the resulting function within the  computation.KRun the simulation and then show the results in the integration time point.JRun the simulation and then show the results in the specified time points.zIt may consume much memory, for we have to traverse all the specified points to create the resulting function within the  computation.&a handle an indenta localisationa handle an indenta labela localisation an indenta localisationa handlea localisationa localisation an indenta localisation an indenta labela localisationa localisation$$&;@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone24[5The resource which can be acquired and then released.+It models an activity that can be utilised.-It models the server that prodives a service.PAccumulates the statistics about that how long the arrived events are processed.+Represents either finite or infinite queue.:A time-dependent counter that collects the statistics too.The time-dependent statistics.4A counter for which the statistics is collected too.0Represents a statistics based upon observations.)Something that can transform the results.Return the result transform.The total number of samples.$The minimum value among the samples.$The maximum value among the samples.The average value.The average square value.Return tha variance.Return the deviation.The counter value.The counter statistics.Return the number of samples.Return the minimum value.Return the maximum value.Return the average value.Return the variance.Return the deviation.1Return the time at which the minimum is attained.1Return the time at which the maximum is attained."Return the start time of sampling.!Return the last time of sampling.Return the sum of values. Return the sum of square values.The counter value.The counter statistics.WThe strategy applied to the enqueueing (input) processes when the finite queue is full.AThe strategy applied when storing (in memory) items in the queue.RThe strategy applied to the dequeueing (output) processes when the queue is empty. Test whether the queue is empty.&Test whether the finite queue is full.The finite queue capacity.Return the current queue size.!Return the queue size statistics.NReturn the total number of input items that were enqueued in the finite queue.5Return the number of lost items for the finite queue.8Return the total number of input items that were stored.Return the total number of requests for dequeueing the items, not taking into account the failed attempts to dequeue immediately without suspension.DReturn the total number of output items that were actually dequeued.FReturn the load factor: the finite queue size divided by its capacity.dReturn the rate of the input items that were enqueued in the finite queue: how many items per time.GReturn the rate of the items that were stored: how many items per time.Return the rate of the requests for dequeueing the items: how many requests per time. It does not include the failed attempts to dequeue immediately without suspension.PReturn the rate of the output items that were dequeued: how many items per time.sReturn the wait time from the time at which the item was stored in the queue to the time at which it was dequeued.Return the total wait time for the finite queue from the time at which the enqueueing operation was initiated to the time at which the item was dequeued.sReturn the wait time from the time at which the item was stored in the queue to the time at which it was dequeued.Return the dequeue wait time from the time at which the item was requested for dequeueing to the time at which it was actually dequeued.mReturn a long-term average queue rate calculated as the average queue size divided by the average wait time.LReturn the statistics about that how long the arrived events were processed. The initial state of the server.'Return the current state of the server.SReturn the counted total time when the server was locked while awaiting the input.NReturn the counted total time spent by the server while processing the tasks.]Return the counted total time when the server was locked while trying to deliver the output.mReturn the counted total time spent by the server while it was preempted waiting for the further proceeding.WReturn the statistics of the time when the server was locked while awaiting the input.RReturn the statistics of the time spent by the server while processing the tasks.aReturn the statistics of the time when the server was locked while trying to deliver the output.qReturn the statistics of the time spent by the server while it was preempted waiting for the further proceeding.wIt returns the factor changing from 0 to 1, which estimates how often the server was awaiting for the next input task.|It returns the factor changing from 0 to 1, which estimates how often the server was busy with direct processing its tasks.It returns the factor changing from 0 to 1, which estimates how often the server was locked trying to deliver the output after the task is finished.It returns the factor changing from 0 to 1, which estimates how often the server was preempted waiting for the further proceeding."The initial state of the activity.)Return the current state of the activity.=Return the counted total time when the activity was utilised.9Return the counted total time when the activity was idle.aReturn the counted total time when the activity was preemted waiting for the further proceeding.BReturn the statistics for the time when the activity was utilised.>Return the statistics for the time when the activity was idle.gReturn the statistics for the time when the activity was preempted waiting for the further proceeding.aIt returns the factor changing from 0 to 1, which estimates how often the activity was utilised.]It returns the factor changing from 0 to 1, which estimates how often the activity was idle.It returns the factor changing from 0 to 1, which estimates how often the activity was preempted waiting for the further proceeding.3Return the current available count of the resource.>Return the statistics for the available count of the resource.5Return the current utilisation count of the resource.@Return the statistics for the utilisation count of the resource.0Return the current queue length of the resource.;Return the statistics for the queue length of the resource.+Return the total wait time of the resource.8Return the statistics for the wait time of the resource.ndddD@Copyright (c) 2009-2015, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone<9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abGHIJKLMNOPQRSTUcdefghijklmnoopqrrstuvwxyz{{|}~<<<<<<<<<<<<<<<<<<<=================>>>>>>>>>>>>>????????????????@@@@@@@@@@@@@@@@@ @ @ @ @ @@@@@@@@@@  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEAFAFAGAHAIJJKLMNOOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxpqrstuvwxByBzB{B|B}B~CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCV.01YW  X    !"#$%&'()*+,-./012[34]5^67Z89:;<=>?@ABCDEFGHV.01YWX   !"#$%&-./012[34]5^67Z9BDEGHIJKLM N O P Q R!N!O"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/R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l1m1m1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~11111111112222222222222222333333333333344444444444444555555555555555566666666666666666666666666666666666666666667777777777777777777777 7 7 7 7 8888888888888888888 8!8"8#8$8%8&8'8(8)8*8+8,8-8.8/808182838485868788898:8;8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L8M8N8O8P8Q8R8S8T8U8V8W8X8Y8Z8[8\8]8^8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u9v9v9w9w9x9x9y9y9z9{9|9}9~999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999:::::::::: : : : : ::::::::::::::::::: :!:":#;;;;;;;;;;;o;o;{;{;r;r;;;$;%;;;;;;;;s;t;|;};~;x;z;;;;;;;;p;q;;;;W;;;X; ;;;;;;; ;!;";#;$;';*;-;0;;;%;(;+;.;1;4;7;:;=;@;C;F;I;;;;;;;;;;;;;;;;;;;&G'()*+V,-./0123456789:;<=>?&G'()*@cABC@DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi<j<k<l<m<n<o<p<q<r<s<t<u<v<w<x<y<z<{<|<}<~<<<<j<n<t=================>>>>>>>>>>>>>>>>>?????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@MQppBBBBBBBBBBBBBBBBBBBBBBBBBBBBBHIBB B B B B BBBBBBBBBBBBBBBBBBBBB BB!B"ByBB#B$B%B&B'B(B)B*B+B,B-B.B/B0B1B2B3C4C5C6C7C8C9C:C;<=<>C?C@CACCCBCCCDCECFCGCHCCCICJCCKCLCMCNCOCPCQCRCSCTCUCVWXHIYHIZ[\]^_`abbcdefghijklmnopqreqrstuvwxX]uyzv{|}x~eruvwxX]^`_auyzv{|}x~efghijklmnopr ####&&'''++++,,,,,//////////////////111111112225555555555555555555566666666666666699999999999 9 9 9 9 99999999999999999999 9!9"9#9$9%9&9'9(9)9*9+9,9-9.9/909192939495969798999:9;9<9=9>9?9@9A9B9C9D9E9F9G9H9I9J9K9L9M9N9O9P9Q9R9S9T9U9V9W9X:Y:Z;[;\;];^;_;`;a;b;c;de aivika-4.2Simulation.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.BaseSimulation.Aivika.QueueStrategySimulation.Aivika.ArrivalSimulation.Aivika.SignalSimulation.Aivika.RefSimulation.Aivika.VarSimulation.Aivika.Var.UnboxedSimulation.Aivika.ContSimulation.Aivika.ProcessSimulation.Aivika.GateSimulation.Aivika.ResourceSimulation.Aivika.Resource.BaseSimulation.Aivika.Task*Simulation.Aivika.Resource.Preemption.BaseSimulation.Aivika.Queue Simulation.Aivika.Queue.Infinite%Simulation.Aivika.Resource.Preemption 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.Process.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.Random'Simulation.Aivika.Processor.RoundRobbinSimulation.Aivika.ServerSimulation.Aivika.Server.RandomSimulation.Aivika.CircuitSimulation.Aivika.NetSimulation.Aivika.Net.RandomSimulation.Aivika.Stream.RandomSimulation.Aivika.AgentSimulation.Aivika.Activity!Simulation.Aivika.Activity.Random Simulation.Aivika.Results.LocaleSimulation.Aivika.ResultsSimulation.Aivika.Results.IO#Simulation.Aivika.Results.Transform Simulation.Aivika.Internal.Specs$Simulation.Aivika.Internal.Parameter%Simulation.Aivika.Internal.Simulation#Simulation.Aivika.Internal.Dynamics Simulation.Aivika.Internal.Event"Simulation.Aivika.Internal.ArrivalSimulation.Aivika.Internal.Cont"Simulation.Aivika.Internal.ProcessSimulation.Aivika tableLookuptableLookupStepwiseVector newVector copyVector vectorCount appendVector readVector writeVectorvectorBinarySearch freezeVector vectorInsertvectorDeleteAt vectorIndex vectorIndexBy vectorDeletevectorDeleteBy PriorityQueue queueNull queueCountnewQueueenqueuedequeue queueFront queueDelete queueDeleteByremoveremoveByUnboxednewUnboxedArray_DoubleLinkedListlistNull listCountnewListlistInsertFirst listAddLastlistRemoveFirstlistRemoveLast listFirstlistLast listRemove listRemoveBy TimingCountertimingCounterValuetimingCounterStatsSamplingCountersamplingCounterValuesamplingCounterStats TimingDataemptyTimingStatsaddTimingStatstimingStatsMeantimingStatsMean2timingStatsVariance TimingStatstimingStatsCounttimingStatsMintimingStatsMaxtimingStatsLasttimingStatsMinTimetimingStatsMaxTimetimingStatsStartTimetimingStatsLastTimetimingStatsSumtimingStatsSum2 SamplingDataemptySamplingStatsaddSamplingStatscombineSamplingStats SamplingStatssamplingStatsCountsamplingStatsMinsamplingStatsMaxsamplingStatsMeansamplingStatsMean2combineSamplingStatsEithersamplingStatsVariancesamplingStatsDeviationreturnSamplingStatslistSamplingStatsfromIntSamplingStatssamplingStatsSummarytimingStatsDeviationreturnTimingStatsfromIntTimingStatsnormTimingStatstimingStatsSummaryemptySamplingCounterincSamplingCounterdecSamplingCountersetSamplingCounterreturnSamplingCounteremptyTimingCounterincTimingCounterdecTimingCountersetTimingCounterreturnTimingCounter GeneratorTypeCustomGenerator01CustomGeneratorSimpleGeneratorWithSeedSimpleGenerator GeneratorgenerateUniformgenerateUniformIntgenerateTriangulargenerateNormalgenerateLogNormalgenerateExponentialgenerateErlanggeneratePoissongenerateBinomial generateGamma generateBetagenerateWeibullgenerateDiscrete DiscretePDF newGeneratornewRandomGeneratorMethod RungeKutta4 RungeKutta2EulerSpecs spcStartTime spcStopTimespcDT spcMethodspcGeneratorTypeintegIterationBndsintegIterationLoBndintegIterationHiBndintegPhaseBndsintegPhaseLoBndintegPhaseHiBnd basicTime integTimes ParameterLift liftParameter Parameter runParameter runParameterssimulationIndexsimulationCountsimulationSpecsgeneratorParametercatchParameterfinallyParameterthrowParameter memoParametertableParameter starttimestoptimedtSimulationAbortSimulationExceptionSimulationLiftliftSimulation Simulation runSimulationrunSimulationscatchSimulationfinallySimulationthrowSimulationmemoSimulation DynamicsLift liftDynamicsDynamicsrunDynamicsInStartTimerunDynamicsInStopTimerunDynamicsInIntegTimesrunDynamicsInTimerunDynamicsInTimes catchDynamicsfinallyDynamics throwDynamicstime isTimeIntegintegIteration integPhase traceDynamicsDisposableEvent disposeEventEventCancellation cancelEventeventCancelled eventFinishedEventProcessingEarlierEventsOrFromPastCurrentEventsOrFromPast EarlierEvents CurrentEvents EventLift liftEventEvent catchEvent finallyEvent throwEvent enqueueEventrunEvent runEventWithrunEventInStartTimerunEventInStopTimeeventQueueCountenqueueEventWithTimesenqueueEventWithIntegTimesenqueueEventWithCancellation memoEventmemoEventInTime yieldEvent traceEventRefnewRefreadRefwriteRef modifyRefStaticPrioritiesSIROLCFSFCFSDeletingQueueStrategystrategyQueueDeletestrategyQueueDeleteByPriorityQueueStrategystrategyEnqueueWithPriorityEnqueueStrategystrategyEnqueueDequeueStrategystrategyDequeue QueueStrategy StrategyQueuenewStrategyQueuestrategyQueueNull SIROQueueStaticPriorityQueue LCFSQueue FCFSQueue$fDeletingQueueStrategySIRO$fEnqueueStrategySIRO$fDequeueStrategySIROTFCo:R:StrategyQueueSIROi$fQueueStrategySIRO'$fDeletingQueueStrategyStaticPriorities-$fPriorityQueueStrategyStaticPrioritiesDouble!$fDequeueStrategyStaticPriorities%TFCo:R:StrategyQueueStaticPrioritiesi$fQueueStrategyStaticPriorities$fDeletingQueueStrategyLCFS$fEnqueueStrategyLCFS$fDequeueStrategyLCFSTFCo:R:StrategyQueueLCFSi$fQueueStrategyLCFS$fDeletingQueueStrategyFCFS$fEnqueueStrategyFCFS$fDequeueStrategyFCFSTFCo:R:StrategyQueueFCFSi$fQueueStrategyFCFSArrival arrivalValue arrivalTime arrivalDelay SignalablereadSignalablesignalableChanged_ SignalHistorysignalHistorySignalSignal handleSignal SignalSource publishSignal triggerSignal handleSignal_newSignalSource mapSignal filterSignal filterSignal_ filterSignalMfilterSignalM_ merge2Signals merge3Signals merge4Signals merge5Signals mapSignalMapSignal emptySignalnewSignalHistorynewSignalHistoryStartingWithreadSignalHistorynewSignalInTimesnewSignalInIntegTimesnewSignalInStartTimenewSignalInStopTimesignalableChangedemptySignalableappendSignalable arrivalSignal traceSignal refChanged refChanged_VarnewVarvarMemoreadVarwriteVar modifyVar freezeVar varChanged varChanged_ContContCancellationCancelInIsolationCancelParentAfterChildCancelChildAfterParentCancelTogether ProcessLift liftProcessProcess ProcessId holdProcessinterruptProcessprocessInterruptedpassivateProcessprocessPassivereactivateProcess runProcessrunProcessUsingIdrunProcessInStartTimerunProcessInStartTimeUsingIdrunProcessInStopTimerunProcessInStopTimeUsingIdenqueueProcessenqueueProcessUsingId processId newProcessIdcancelProcessWithId cancelProcessprocessCancelledprocessCancellingwhenCancellingProcessprocessPreemptionBeginningprocessPreemptionEnding catchProcessfinallyProcess throwProcessprocessParallelprocessParallelUsingIdsprocessParallel_processParallelUsingIds_processUsingId spawnProcessspawnProcessUsingIdspawnProcessWithspawnProcessUsingIdWith processAwait memoProcesszipProcessParallelzip3ProcessParallel unzipProcesstimeoutProcesstimeoutProcessUsingId processYield neverProcess traceProcessGatenewGate newGateOpened newGateClosedopenGate closeGate gateOpened gateClosedawaitGateOpenedawaitGateClosed gateChanged_ResourceresourceStrategyresourceMaxCountPriorityResource SIROResource LCFSResource FCFSResourcenewFCFSResourcenewFCFSResourceWithMaxCountnewLCFSResourcenewLCFSResourceWithMaxCountnewSIROResourcenewSIROResourceWithMaxCountnewPriorityResourcenewPriorityResourceWithMaxCount newResourcenewResourceWithMaxCount resourceCountresourceCountStatsresourceCountChangedresourceCountChanged_resourceUtilisationCountresourceUtilisationCountStatsresourceUtilisationCountChanged resourceUtilisationCountChanged_resourceQueueCountresourceQueueCountStatsresourceQueueCountChangedresourceQueueCountChanged_resourceTotalWaitTimeresourceWaitTimeresourceWaitTimeChangedresourceWaitTimeChanged_requestResourcerequestResourceWithPriorityreleaseResourcereleaseResourceWithinEventtryRequestResourceWithinEvent usingResourceusingResourceWithPriorityincResourceCountdecResourceCountresourceChanged_ TaskResult TaskCancelled TaskError TaskCompletedTasktaskIdtaskResultReceivedtryGetTaskResult taskResult cancelTask taskCancelledrunTaskUsingIdrunTaskenqueueTaskUsingId enqueueTaskspawnTaskUsingId spawnTaskspawnTaskUsingIdWith spawnTaskWith taskProcesstaskParallelResulttaskParallelProcessalterResourceCountQueue queueMaxCountenqueueStrategyenqueueStoringStrategydequeueStrategy newFCFSQueue newLCFSQueue newSIROQueuenewPriorityQueuequeueNullChangedqueueNullChanged_ queueFullqueueFullChangedqueueFullChanged_queueCountStatsqueueCountChangedqueueCountChanged_ enqueueCountenqueueCountChangedenqueueCountChanged_enqueueLostCountenqueueLostCountChangedenqueueLostCountChanged_enqueueStoreCountenqueueStoreCountChangedenqueueStoreCountChanged_ dequeueCountdequeueCountChangeddequeueCountChanged_dequeueExtractCountdequeueExtractCountChangeddequeueExtractCountChanged_queueLoadFactorqueueLoadFactorChangedqueueLoadFactorChanged_ enqueueRateenqueueStoreRate dequeueRatedequeueExtractRate queueWaitTimequeueWaitTimeChangedqueueWaitTimeChanged_queueTotalWaitTimequeueTotalWaitTimeChangedqueueTotalWaitTimeChanged_enqueueWaitTimeenqueueWaitTimeChangedenqueueWaitTimeChanged_dequeueWaitTimedequeueWaitTimeChangeddequeueWaitTimeChanged_ queueRatequeueRateChangedqueueRateChanged_dequeueWithOutputPriority tryDequeue queueDelete_queueDeleteBy_ clearQueueenqueueWithInputPriorityenqueueWithStoringPriority!enqueueWithInputStoringPriorities tryEnqueuetryEnqueueWithStoringPriority enqueueOrLost enqueueWithStoringPriorityOrLostenqueueOrLost_!enqueueWithStoringPriorityOrLost_enqueueInitiated enqueueStored enqueueLostdequeueRequesteddequeueExtractedwaitWhileFullQueue queueChanged_ queueSummary initDynamicsdiscreteDynamicsinterpolateDynamics scan1Dynamics scanDynamics memoDynamics memo0DynamicsiterateDynamics unzipDynamicsunzip0DynamicsmemoRandomUniformDynamicsmemoRandomUniformIntDynamicsmemoRandomTriangularDynamicsmemoRandomNormalDynamicsmemoRandomLogNormalDynamicsmemoRandomExponentialDynamicsmemoRandomErlangDynamicsmemoRandomPoissonDynamicsmemoRandomBinomialDynamicsmemoRandomGammaDynamicsmemoRandomBetaDynamicsmemoRandomWeibullDynamicsmemoRandomDiscreteDynamics.==../=..<..>=..>..<=. maxDynamics minDynamics ifDynamicsinteg integEithersmoothIsmoothsmooth3Ismooth3smoothNIsmoothNdelay1Idelay1delay3Idelay3delayNIdelayNforecasttrenddiffsum diffsumEitherlookupDynamicslookupStepwiseDynamicsdelaydelayInpvnpvesteppulsepulsePramp randomUniformrandomUniformIntrandomTriangular randomNormalrandomLogNormalrandomExponential randomErlang randomPoissonrandomBinomial randomTrue randomFalse randomGamma randomBeta randomWeibullrandomDiscreterandomUniformProcessrandomUniformProcess_randomUniformIntProcessrandomUniformIntProcess_randomTriangularProcessrandomTriangularProcess_randomNormalProcessrandomNormalProcess_randomLogNormalProcessrandomLogNormalProcess_randomExponentialProcessrandomExponentialProcess_randomErlangProcessrandomErlangProcess_randomPoissonProcessrandomPoissonProcess_randomBinomialProcessrandomBinomialProcess_randomGammaProcessrandomGammaProcess_randomBetaProcessrandomBetaProcess_randomWeibullProcessrandomWeibullProcess_randomDiscreteProcessrandomDiscreteProcess_TimingStatsAccumulatortimingStatsAccumulatednewTimingStatsAccumulator Transform runTransform timeTransformdelayTransformintegTransformintegTransformEither sumTransformsumTransformEither 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 delayStreamsingletonStream joinStreamfailoverStream takeStreamtakeStreamWhiletakeStreamWhileM dropStreamdropStreamWhiledropStreamWhileM traceStream Processor runProcessoremptyProcessor arrProcessoraccumProcessorwithinProcessorprocessorUsingIdprocessorQueuedParallel#processorPrioritisingOutputParallel"processorPrioritisingInputParallel(processorPrioritisingInputOutputParallelprocessorParallel processorSeqbufferProcessorbufferProcessorLoopqueueProcessorqueueProcessorLoopMergingqueueProcessorLoopSeqqueueProcessorLoopParallelprefetchProcessorsignalProcessorprocessorSignalingarrivalProcessordelayProcessor joinProcessorfailoverProcessortraceProcessorrandomUniformProcessorrandomUniformIntProcessorrandomTriangularProcessorrandomNormalProcessorrandomLogNormalProcessorrandomExponentialProcessorrandomErlangProcessorrandomPoissonProcessorrandomBinomialProcessorrandomGammaProcessorrandomBetaProcessorrandomWeibullProcessorrandomDiscreteProcessorroundRobbinProcessorroundRobbinProcessorUsingIdsServerserverInitState newServernewStateServernewPreemptibleServernewPreemptibleStateServerserverProcessor serverStateserverStateChangedserverStateChanged_serverTotalInputWaitTimeserverTotalInputWaitTimeChanged serverTotalInputWaitTimeChanged_serverTotalProcessingTime serverTotalProcessingTimeChanged!serverTotalProcessingTimeChanged_serverTotalOutputWaitTime serverTotalOutputWaitTimeChanged!serverTotalOutputWaitTimeChanged_serverTotalPreemptionTime serverTotalPreemptionTimeChanged!serverTotalPreemptionTimeChanged_serverInputWaitTimeserverInputWaitTimeChangedserverInputWaitTimeChanged_serverProcessingTimeserverProcessingTimeChangedserverProcessingTimeChanged_serverOutputWaitTimeserverOutputWaitTimeChangedserverOutputWaitTimeChanged_serverPreemptionTimeserverPreemptionTimeChangedserverPreemptionTimeChanged_serverInputWaitFactorserverInputWaitFactorChangedserverInputWaitFactorChanged_serverProcessingFactorserverProcessingFactorChangedserverProcessingFactorChanged_serverOutputWaitFactorserverOutputWaitFactorChangedserverOutputWaitFactorChanged_serverPreemptionFactorserverPreemptionFactorChangedserverPreemptionFactorChanged_serverInputReceivedserverTaskPreemptionBeginningserverTaskPreemptionEndingserverTaskProcessedserverOutputProvidedserverChanged_ serverSummarynewRandomUniformServernewRandomUniformIntServernewRandomTriangularServernewRandomNormalServernewRandomLogNormalServernewRandomExponentialServernewRandomErlangServernewRandomPoissonServernewRandomBinomialServernewRandomGammaServernewRandomBetaServernewRandomWeibullServernewRandomDiscreteServer!newPreemptibleRandomUniformServer$newPreemptibleRandomUniformIntServer$newPreemptibleRandomTriangularServer newPreemptibleRandomNormalServer#newPreemptibleRandomLogNormalServer%newPreemptibleRandomExponentialServer newPreemptibleRandomErlangServer!newPreemptibleRandomPoissonServer"newPreemptibleRandomBinomialServernewPreemptibleRandomGammaServernewPreemptibleRandomBetaServer!newPreemptibleRandomWeibullServer"newPreemptibleRandomDiscreteServerCircuit runCircuitcircuitSignalingcircuitProcessor arrCircuit accumCircuitarrivalCircuit delayCircuit timeCircuit>?>>>serverProcessPreempting<<<iterateCircuitInPoints_iterateCircuitInPointsiterateCircuitInPointsMaybeiterateCircuitInPointsEither$fArrowChoiceCircuit$fArrowLoopCircuit$fArrowCircuit$fCategory*Circuit$fArrowChoiceNet $fArrowNet$fCategory*NetarrivalProcessingTimeRef"arrivalProcessingTimeChangedSourcetriggerAgentStateChanged AgentModeProcessingMode TransientMode CreationModestateActivateRefstateDeactivateRefstateTransitRefstateVersionRef agentModeRef agentStateRefagentStateChangedSourcefullPath partitionPathfindPath traversePath$fEqAgentState $fEqAgentactivityStateRefactivityProcessactivityProcessPreemptibleactivityTotalUtilisationTimeRefactivityTotalIdleTimeRefactivityTotalPreemptionTimeRefactivityUtilisationTimeRefactivityIdleTimeRefactivityPreemptionTimeRefactivityUtilisingSourceactivityUtilisedSource!activityPreemptionBeginningSourceactivityPreemptionEndingSourceactivityProcessPreempting apResultValuenormTimingStatsDataflattenResultSourceresultSourceNameexpandResultSourceresultSourceSummaryresultSourceSignal concatResults appendResultssamplingStatsResultSourcesamplingStatsResultSummarytimingStatsResultSourcetimingStatsResultSummarysamplingCounterResultSourcesamplingCounterResultSummarytimingCounterResultSourcetimingCounterResultSummaryqueueResultSourcequeueResultSummaryinfiniteQueueResultSourceinfiniteQueueResultSummaryarrivalTimerResultSourcearrivalTimerResultSummaryserverResultSourceserverResultSummaryactivityResultSourceactivityResultSummaryresourceResultSourceresourceResultSummarypreemptibleResourceResultSource preemptibleResourceResultSummary intSubscript$fResultProviderResource$fResultProviderResource0$fResultProviderActivity$fResultProviderServer$fResultProviderArrivalTimer$fResultProviderQueue$fResultProviderQueue0$fResultProviderm$fResultProviderm0$fResultProviderm1$fResultProviderm2)$fResultProviderResultVectorWithSubscript($fResultProviderResultArrayWithSubscript'$fResultProviderResultListWithSubscript$fResultProviderVector$fResultProviderArray$fResultProvider[]$fResultProviderm3$fResultProviderm4$fResultProviderm5$fResultProviderm6$fResultProviderm7$fResultProviderm8$fResultProviderm9$fResultProviderm10$fResultProviderm11$fResultProviderm12$fResultProviderm13$fResultProviderm14$fResultProviderm15$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 showResultSourceIndentedLabelled$fResultTransformerResource$fResultTransformerActivity$fResultTransformerServer$fResultTransformerArrivalTimer$fResultTransformerQueue $fResultTransformerTimingCounter$fResultTransformerTimingStats"$fResultTransformerSamplingCounter $fResultTransformerSamplingStats$fResultTransformer(->)