}C      !"#$%&'()*+,-./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 { |}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                          !!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+","-"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"?"@"A"B"C"D"E"F"G"H"I"J"K"L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_#`#a#b#c#d#e#f$g$h$i$j$k$l$m$n$o$p$q$r$s%t%u%v%w%x%y%z%{%|%}%~%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'' ' ' ' ' '(((((((((((()))))) )!)")#)$)%)&)')()))*)+),)-).)/)0)1)2)3)4)5)6)7)8)9):);)<)=)>)?)@)A)B)C)D)E)F)G*H*I*J*K*L*M*N*O*P*Q*R*S*T*U*V*W*X*Y*Z*[*\*]*^*_*`*a*b*c*d*e+f+g+h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,{,|,},~---------.........///////////////////////////////////////////////////////////////0000000011111111111111111111111111111111111222222222222222 2 2 2 2 2222222222222233333 3!3"3#3$3%3&3'3(3)3*3+3,3-3.4/404142434445464748494:4;5<5=5>5?5@5A5B5C5D5E5F5G5H6I6J7K7L7M7N7O7P7Q7R7S7T7U7V7W7X7Y7Z7[7\7]7^7_7`7a7b7c7d7e7f7g7h7i7j7k7l7m7n7o7p7q7r7s7t7u7v7w7x7y7z7{7|7}7~7788888888888888888888888888999999999::::::::::::::;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<============================================>>>>>>>>>>>> > > > > >>>>>>>>>>????????? ?!?"?#?$?%?&?'?(?)?*?+?,?-?.?/?0?1?2?3?4@5@6@7@8@9@:@;@<@=@>@?@@@A@B@C@D@E@F@G@H@I@J@K@L@M@NAOAPAQARASATAUAVAWAXAYAZA[A\A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}A~AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB B B B B BBBBBBBBBBBBBBBBBBB B!B"B#B$B%B&B'B(B)B*B+B,B-B.B/B0B1B2B3B4B5B6B7B8B9B:B;B<B=B>B?B@BABBBCBDBEBFBGBHBIBJBKBLBMBNBOBPBQBRBSBTBUBVBWBXBYBZB[B\B]B^B_B`BaBbBcBdBeBfBgBhBiBjBkBlBmBnBoBpBqBrBsBtBuBvBwBxByBzB{B|B}B~BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD D D D D DDDDDDDDDDDDDDDDDDD D!D"D#D$D%D&D'D(D)D*D+D,D-D.D/D0D1D2D3D4D5D6D7D8D9D:D;D<D=D>D?D@DADBDL@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalSafe:Represents a resizable vector.Create a new vector.Copy the vector.C2Ensure 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. 'Delete the specified range of elements. (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.@Detect whether the specified element is contained in the vector.XDetect whether an element satisfying the specified predicate is contained in the vector.DEFGCH  the vectorthe start index the count of items to be removed    DEFGCH @Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalSafe:;The type which values can be contained in an unboxed array.,Create an unboxed array with default values. ! !@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalSafe:"'Represents an unboxed resizable vector.#Create a new vector.$Copy the vector.I2Ensure 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.-'Delete the specified range of elements..(Return the index of the item or -1. /@Return an index of the item satisfying the predicate or -1. 0eRemove the specified element and return a flag indicating whether the element was found and removed.1uRemove an element by the specified predicate and return a flag indicating whether the element was found and removed.2@Detect whether the specified element is contained in the vector.3XDetect whether an element satisfying the specified predicate is contained in the vector."JKLM#$I%&'(N)*+,- the vectorthe start index the count of items to be removed./0123"#$%&'()*+,-./0123"#$%&'()+,-01./23*"JKLM#$I%&'(N)*+,-./0123@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalSafe4Lookup x in a table of pairs (x, y) using linear interpolation.5Lookup x in a table of pairs (x, y) using stepwise function.45454545@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalSafe05;6;A counter for which the timing statistics is collected too.8The counter value.9The counter statistics.:4A counter for which the statistics is collected too.<The counter value.=The counter statistics.>LDefines the data type from which values we can gather the timing statistics.?(An empty statistics that has no samples.@7Add a sample with the specified time to the statistics.AReturn the average value.B Return the average square value.CReturn the variance.D?This is the timing statistics where data are bound to the time.FReturn the number of samples.GReturn the minimum value.HReturn the maximum value.IReturn the last value.J1Return the time at which the minimum is attained.K1Return the time at which the maximum is attained.L"Return the start time of sampling.M!Return the last time of sampling.NReturn the sum of values.O Return the sum of square values.PNSpecifies data type from which values we can gather the statistics. Q3An empty statistics that has no samples. R#Add a new sample to the statistics.SCombine two statistics.TZDescribes when the statistics consists of only samples not bound to the simulation time.VThe total number of samples.W$The minimum value among the samples.X$The maximum value among the samples.YThe average value.ZThe average square value.O,Defines data types that can be converted to P.QConvert the value to P.[cIf allows combining statistics more efficiently if we know that the first argument can be a scalar.\Return the variance.]Return the deviation. ^)Return the statistics by a single sample._4Create the statistics by the specified list of data.`5Convert the statistics from integer to double values.R*Show the summary of the statistics. aEShow the summary of the statistics using the specified indent. b#Return the deviation. c,Return the statistics by single timing data.d5Convert the statistics from integer to double values.eConvert the statistics to its normalised sampling-based representation, where the first argument specifies the number of pseudo-samples.S*Show the summary of the statistics. fEShow the summary of the statistics using the specified indent. gAn empty counter.hIncrease the counter.iDecrease the counter.j Set a new value for the counter.k2Create a counter with the specified initial value.lAn empty counter.m+Increase the counter at the specified time.n+Decrease the counter at the specified time.o6Set a new value for the counter at the specified time.pKCreate a timing counter with the specified initial value at the given time.V6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZOQTU[\]^_`RaVWXYbcdeSfghijklmnopqrstuvwxyz{|}~;6789:;<=>AC?@BDEFGHJKLMNOIPQRSTUVWXYZ[\]^_`abcdefghijklmnop;TUVWXYZPQRS[\]a^_`DEFGHIJKLMNO>?@ABCbfcde:;<=ghijk6789lmnop66789:;<=>?@ABCD EFGHIJKLMNOPQRSTUVWXYZOQTU[\]^_`RaVWXYbcdeSfghijklmnopqrstuvwxyz{|}~@Copyright (c) 2015-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalSafe The 8 type represents an immutable heap-based priority queue.)Test whether the priority queue is empty.4Return the number of elements in the priority queue.An empty priority queue.2Enqueue a new element with the specified priority..Dequeue the element with the minimal priority.-Return the element with the minimal priority.Z&Return the rank of the priority queue.[Construct a new priority queue.\Merge two priority queues. ]^Z[\ ]^Z[\@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalSafe: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).?Detect whether the specified element is contained in the queue.8Note that unlike other functions it has complexity O(n).MDetect whether an element satisfying the predicate is contained in the queue.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.`abcdef_ `abcdef_@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneOT$.Defines a type of the random number generator.#The simple random number generator.;The simple random number generator with the specified seed.#The custom random number generator.^The custom random number generator by the specified uniform generator of numbers from 0 to 1."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.@Generate a sequence number which can be considered quite unique.(A discrete probability density function.gJGenerate the uniform random number with the specified minimum and maximum.hJGenerate the uniform random number with the specified minimum and maximum.iSGenerate the triangular random number by the specified minimum, median and maximum.jCreate a normal random number generator with mean 0 and variance 1 by the specified generator of uniform random numbers from 0 to 1.k=Return the exponential random number with the specified mean.l Return the Erlang random number.m;Generate the Poisson random number with the specified mean.nWGenerate a binomial random number with the specified probability and number of trials. oVGenerate a random number from the Gamma distribution using Marsaglia and Tsang method.p4Generate a random number from the Beta distribution.q7Generate a random number from the Weibull distribution.rAGenerate 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.XCreate a new random generator by the specified uniform generator of numbers from 0 to 1.%g the generatorminimummaximumh the generatorminimummaximumi the generatorminimummedianmaximumj the generatork the generatorthe meanl the generator the scale the shapem the generatorthe meann the generatorthe probabilitythe number of trialso a normal random number ~ N (0,1)#an uniform random number ~ U (0, 1)the shape parameter (kappa) the scale parameter (theta)p!a normal random number ~ N (0, 1)#an uniform random number ~ U (0, 1)the shape parameter alphathe shape parameter betaq#an uniform random number ~ U (0, 1)shapescaler#an uniform random number ~ U (0, 1)'a discrete probability density functionghijklmnopqr @Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone*It represents the event queue.the underlying priority queue0whether the queue is currently processing events"the actual time of the event queueIIt defines the simulation point appended with the additional information.the simulation specsthe simulation runthe current timethe current iterationthe current phase"It indentifies the simulation run.the simulation specs the current simulation run index+the total number of runs in this experimentthe event queuethe random number generator"It defines the integration method.Euler's method the 2nd order Runge-Kutta method the 4th order Runge-Kutta method It defines the simulation specs.the start time the stop timethe integration time stepthe integration method'the type of the random number generator0Create a new event queue by the specified specs.s6Returns 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.tIReturns 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.#Return the integration time points.Return the start time point.Return the stop time point.'Return the point at the specified time.HReturn the integration time points startin from the specified iteration..st,,st @Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneJ: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 u function.Like the standard v function. 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."wxyz   wxyz  E@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone @Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone0AJT An exception that signals that the current computation should be retried as possible, which feature may be supported by the simulation engine or not. 'The exception to retry the computation. 5An 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.BRun the simulation by the specified specs and run index in series.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 u function.Like the standard v function. Invoke the  computation. Memoize the G computation, always returning the same value within a simulation run."   {|the simulation modelthe simulation specsthe number of runs in series-the index of the current run (started from 1)}~ !"#$%&'(         {|}~ !"#$%&'( @Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneJ+A 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.0Run the -% computation in the final time point.1Run the -, computation in all integration time points.2Run the -) computation in the specified time point.3Run the -* computation in the specified time points.4Exception handling within - computations.5.A computation with finalization part like the u function.6Like the standard v function.7 Invoke the - computation.85Computation that returns the current simulation time.90Whether 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.%+,-./0123456789:;<=>?@ABCDEFGHI+,-./0123456789:;<-.+,7/012345689:;<#+,-./0123456789:;<=>?@ABCDEFGHI @Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneJ*J,Defines a computation disposing some entity.LDispose something within the X computation.MIt allows cancelling the event.NCancel the event.O%Test whether the event was cancelled.P2Test whether the event was processed and finished.Q%Defines how the events are processed.Reither 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 X5 computation as this is protected by the type system)Seither 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 X5 computation as this is protected by the type system)Teither 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)Ueither 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)VA type class to lift the X# computation to other computations.WLift the specified X$ computation to another computation.XA value in the Xk monad represents a polymorphic time varying function which is strongly synchronized with the event queue.ZException handling within X computations.[.A computation with finalization part like the u function.\Like the standard v function.] Invoke the X 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 X8 computation in the current simulation time within the -$ computation involving all pending R in the processing too.`Run the X8 computation in the current simulation time within the -S computation specifying what pending events should be involved in the processing.aRun the X6 computation in the start time involving all pending R in the processing too.bRun the X5 computation in the stop time involving all pending R in the processing too.cAReturn the number of pending events that should be yet actuated.d7Actuate the event handler in the specified time points.e7Actuate the event handler in the specified time points.f9Actuate the event handler in the integration time points.g2Actuate the event handler in the start time point.h2Actuate the event handler in the final time point.i/Enqueue the event with an ability to cancel it.j Memoize the XG computation, always returning the same value within a simulation run.k Memoize the X 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 X computation is always synchronized with the event queue which time flows in one direction only. This synchronization is a key difference between the X and - computations.lREnqueue the event which must be actuated with the current modeling time but later.mNRetry the current computation as possible, using the specified argument as a  & exception message in case of failure.n8Show the debug message with the current simulation time.=JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx%JKLMPONQRSTUVWXYZ[\]^_`abcdefghijklmn(XYVWQRSTU]_`ab^ighdeflcMNOPNOPZ[\jkJKLmn1JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone|The |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 X monad.}Create a new reference.~Read the value of a reference.%Write a new value into the reference.%Mutate the contents of the reference.|}~|}~|}~|}~F@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone      G@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneH@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone"JKLMPONQRSTUVWXZ[\^_`abcdfghijklmn%XVWQRSTU_`ab^ighdflcMNOPNOPZ[\jkJKLmn@Copyright (c) 2009-2017, 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 X 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 event2the simulation time at which the event has arrivedMthe delay time which has passed from the time of arriving the previous event@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneJReturn 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-2017, 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-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone: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 .@Copyright (c) 2009-2017, 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-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneJ%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%%)I@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone+,-/012345689:;<-+,/012345689:;<@Copyright (c) 2009-2017, 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-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneJOIt 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 transformthe 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   @Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneA 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-2017, 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-2017, 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 .@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalSafeThe 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.Create a new list.&Insert a new element in the beginning.Add a new element to the end.Remove the first element.Remove the last element.Return the first element.Return the last element.sRemove the specified element from the list and return a flag indicating whether the element was found and removed.VRemove an element satisfying the specified predicate and return the element if found.>Detect whether the specified element is contained in the list.VDetect whether an element satisfying the specified predicate is contained in the list.Clear the contents of the list.(Freeze the list and return its contents.@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone<=?DR#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.?Detect whether the specified element is contained in the queue.VDetect whether an element satifying the specified predicate is contained in the queue.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./      !"#$%&'()     /     )('&%$#"!       !"$#%&')(@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone<=J6A type class to lift the 8# computation to other computations.7Lift the specified 8$ computation to another computation.8FIt represents a composite which can be then destroyed in case of need.93Run the computation returning the result and some Jn that being applied destroys the composite, for example, unsubscribes from signals or cancels the processes.:Like 97 but retains the composite parts during the simulation.;Like :, but runs the computation in the start time.<Like :+ but runs the computation in the stop time.=DWhen destroying the composite, the specified action will be applied.6789:;<=>?@ABCDEFG6789:;<= 89679:;<=6789:;<=>?@ABCDEFG@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone-HBDescribes a computation that also signals when changing its value.J"Return a computation of the value.KtReturn a signal notifying that the value has changed but without providing the information about the changed value.L,Represents the history of the signal values.M,The signal for which the history is created.?It contains the information about the disposable queue handler.The queue of signal handlers.N/The signal that can have disposable handlers. PSubscribe the handler to the specified signal and return a nested computation within a disposable object that, being applied, unsubscribes the handler from this signal.Q.The signal source that can publish its signal.RPublish the signal.SWTrigger the signal actuating all its handlers at the current simulation time point.TkSubscribe the handler to the specified signal forever. To subscribe the disposable handlers, use function P.ULike P but within the 8 computation.VCreate a new signal source.!Trigger all next signal handlers.KEnqueue the handler and return its representative in the queue. #Dequeue the handler representative.W0Map the signal according the specified function.XGFilter only those signal values that satisfy the specified predicate.YdFilter only those signal values that satisfy the specified predicate, but then ignoring the values.ZFFilter only those signal values that satisfy the specified predicate.[dFilter only those signal values that satisfy the specified predicate, but then ignoring the values.\Merge two signals.]Merge three signals.^Merge four signals._Merge five signals.`Compose the signal.aTransform the signal.b)An empty signal which is never triggered.c&Create a history of the signal values.dPCreate a history of the signal values starting with the optional initial value.e"Read the history of signal values.)Trigger the signal with the current time.f?Return a signal that is triggered in the specified time points.gdReturn a signal that is triggered in the integration time points. It should be called with help of a.hWReturn a signal that is triggered in the start time. It should be called with help of a.i4Return a signal that is triggered in the final time.j5Return a signal notifying that the value has changed.kReturn an identity.lAn associative operation.mTransform 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.n8Delay the signal values for the specified time interval.oGDelay the signal values for time intervals recalculated for each value.p8Show the debug message with the current simulation time.=HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu)HIJKLMNOPQSRTUVWXYZ[\]^_`abcdefghijklmnop,NOPTUQRSVRSW`aXYZ[b\]^_mfghinoLMMcdeHIJKjklp,HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone8v,Represents a temporarily frozen computation.wUnfreeze the computation.&The auxiliary continuation parameters.xThe continuation parameters.yThe y! type is similar to the standard Cont] monad and F# async workflow but only the result of applying the continuations return the X computation.{!The event that occurs within the y computation.|Cancel the computation.}Preempt the computation.~4Proceed with the computation after if was preempted.It identifies the y computation.EIt defines how the parent and child computations should be cancelled.&Cancel the both computations together.,Cancel the child if its parent is cancelled.,Cancel the parent if its child is cancelled.%Cancel the computations in isolation. 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 y 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 v* function is not handled properly within yN 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 v function but within the ; computation, which allows already handling the exception.Run the yx 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 X 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 y+ computation with the specified identifier.Run the y6 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.mLike the GoTo statement it transfers the direction of computation, but raises an exception when used within  or .8Show the debug message with the current simulation time.Uvwxyz{|}~ the parenthow to connect the child%computation of the disposable handlerthe computation to runthe main branch !the branch for handing exceptionsthe branch for cancellationthe computation identifier<whether to support the exception handling from the beginningAthe list of: the nested computation, the computation identifierAthe list of: the nested computation, the computation identifier/vwxyz{|}~0{|}~yzxvww=vwxyz{|}~J@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneyy@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone>The result of memoization.A type class to lift the # computation to other computations.Lift the specified $ computation to another computation.VSpecifies a discontinuous process that can suspend at any time and then resume later. Represents a process identifier.Invoke the process computation./Hold the process for the specified time period.YInterrupt a process with the specified identifier if the process is held by computation .GTest whether the process with the specified identifier was interrupted.:Return the expected interruption time after finishing the P computation, which value may change if the corresponding process is preempted.NDefine a reaction when the process with the specified identifier is preempted.Passivate the process.4Passivate the process before performing some action.ETest whether the process with the specified identifier is passivated.3Reactivate a process with the specified identifier.?Reactivate a process with the specified identifier immediately.-Prepare the processes identifier for running.#Run immediately the process. A new - identifier will be assigned to the process.;To run the process at the specified time, you can use the  function.Run 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 .;To run the process at the specified time, you can use the  function.ERun the process in the start time immediately involving all pending R in the computation too.hRun the process in the start time immediately using the specified identifier and involving all pending R in the computation too.PRun the process in the final simulation time immediately involving all pending R in the computation too.tRun the process in the final simulation time immediately using the specified identifier and involving all pending R in the computation too.ZEnqueue the process that will be then started at the specified time from the event queue.ZEnqueue the process that will be then started at the specified time from the event queue.&Return the current process identifier. Create a new process identifier.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.0Preempt 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  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 v* function is not handled properly within N 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 v 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 7 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  computation.^At the same time, the interruption has no such effect as it requires explicit specifying the  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  and X; 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.NRetry the current computation as possible, using the specified argument as a  & exception message in case of failure.mLike the GoTo statement it transfers the direction of computation, but raises an exception when used within  or .8Show the debug message with the current simulation time.[::NK@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone66 @Copyright (c) 2009-2017, 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 heldKthe 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)Ka computation of the time interval for which the process was actually held3the 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 held the 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-2017, 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 X monad; otherwise, returning .&rAcquire the resource, perform some action and safely release the resource in the end, even if the  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  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.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 indefinite !the requested resource"the requested resource the priority#the resource to release$the resource to release%(the resource which we try to request for&Dthe 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 action'Ethe 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* !"#$%&'() !"%#$&'() !"#$%&'()*"@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone%+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.0dA type synonym for the queue with static priorities applied when storing the elements in the queue.1=A type synonym for the SIRO (Serviced in Random Order) queue.2fA type synonym for the ordinary LIFO queue also known as the LCFS (Last Come - First Serviced) queue.3gA type synonym for the ordinary FIFO queue also known as the FCFS (First Come - First Serviced) queue.46Create a new FCFS queue with the specified capacity. 56Create a new LCFS queue with the specified capacity. 66Create a new SIRO queue with the specified capacity. 7:Create a new priority queue with the specified capacity. 8@Create a new queue with the specified strategies and capacity. 9 Test whether the queue is empty. See also queueNullChanged and queueNullChanged_.:Test whether the queue is full. See also queueFullChanged and queueFullChanged_.;Return the current queue size. See also queueCountStats, queueCountChanged and queueCountChanged_.<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.AORemove an item satisfying the specified predicate and return the item if found.B2Remove an item satisfying the specified predicate.C2Detect whether the item is contained in the queue.DTDetect whether an item satisfying the specified predicate is contained in the queue.EClear the queue immediately.F?Enqueue the item suspending the process if the queue is full. GWEnqueue with the input priority the item suspending the process if the queue is full. HYEnqueue with the storing priority the item suspending the process if the queue is full. IeEnqueue with the input and storing priorities the item suspending the process if the queue is full. J Try to enqueue the item. Return # in the monad if the queue is full.K:Try to enqueue with the storing priority the item. Return $ in the monad if the queue is full.Store the item.!Store with the priority the item.,Extract an item for the dequeuing request. CA post action after extracting the item by the dequeuing request. *+,-./012345678Othe 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 capacity9:;< 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 queueA the queue the predicateB the queue the predicateC the queue the item to search the queue forwhether the item was foundD the queue the predicatethe item if it was foundE the queueF the queuethe item to enqueueG the queuethe priority for inputthe item to enqueueH the queuethe priority for storingthe item to enqueueI the queuethe priority for inputthe priority for storingthe item to enqueueJ the queue the item which we try to enqueueK the queuethe priority for storing the item which we try to enqueue the queuethe item to be stored the queuethe priority for storingthe item to be enqueued the queuethe dequeued value the queuethe item to dequeuethe dequeued value!+,/.-0123456789:;<=>?@ABCDEFGHIJK%3210+,-./45678-./9:,;<=>FGHIJK?@ABCDE!+ ,-./0123456789:;<=>?@ABCDEFGHIJK#@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneL_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.MAThe strategy applied when storing (in memory) items in the queue.N:The strategy applied to the dequeueing (output) processes.OdA type synonym for the queue with static priorities applied when storing the elements in the queue.P=A type synonym for the SIRO (Serviced in Random Order) queue.QfA type synonym for the ordinary LIFO queue also known as the LCFS (Last Come - First Serviced) queue.RgA type synonym for the ordinary FIFO queue also known as the FCFS (First Come - First Serviced) queue.S#Create a new infinite FCFS queue. T#Create a new infinite LCFS queue. U#Create a new infinite SIRO queue. V'Create a new infinite priority queue. W<Create a new infinite queue with the specified strategies. X Test whether the queue is empty. See also queueNullChanged and queueNullChanged_.YReturn the current queue size. See also queueCountStats, queueCountChanged and queueCountChanged_.Z5Dequeue 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.a2Detect whether the item is contained in the queue.bTDetect whether an item satisfying the specified predicate is contained in the queue.cClear the queue immediately.dEnqueue the item. e-Enqueue with the storing priority the item. Store the item.!Store with the priority the item. ,Extract an item for the dequeuing request. CA post action after extracting the item by the dequeuing request. "L MN   OPQRSTUVW4the strategy applied when storing items in the queueQthe strategy applied to the dequeueing (output) processes when the queue is emptyXYZ 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 predicatea the queue the item to search the queue forwhether the item was foundb the queue the predicatethe item if it was foundc the queued the queuethe item to enqueuee 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 dequeued value  the queuethe item to dequeuethe dequeued valueLNMOPQRSTUVWXYZ[\]^_`abcdeRQPOLMNSTUVWMNXYZ[\de]^_`abcL MN   OPQRSTUVWXYZ[\]^_`abcde $@Copyright (c) 2009-2017, 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.f"Represents a preemptible resource.g0Return the maximum count of the resource, where - means that the resource has no upper bound.h\Create a new resource with the specified initial count that becomes the upper bound as well.iLCreate a new resource with the specified initial and maximum counts, where , means that the resource has no upper bound.j)Return the current count of the resource.kRequest 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.l{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.mAcquire the resource with the specified priority, perform some action and safely release the resource in the end, even if the  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. nIncrease the count of available resource by the specified number, invoking the awaiting and preempted processes according to their priorities as needed.oDecrease the count of available resource by the specified number, preempting the processes according to their priorities as needed.pHAlter the resource count either increasing or decreasing it by calling n or o respectively. !           f g   h9the initial count (and maximal count too) of the resourcei!the initial count of the resource:the maximum count of the resource, which can be indefinitejkthe requested resource3the priority (the less value has a higher priority)lthe resource to release the resource to releasemEthe 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 n the resource$the increment for the resource counto the resource$the decrement for the resource countp the resourcea change of the resource countqr fghijklmnop fghigjklmnop            f g   hijkl m nopqr%@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneg -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.sJRepresents 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.tThe queue capacity.uPThe strategy applied to the enqueueing (input) processes when the queue is full.vAThe strategy applied when storing (in memory) items in the queue.wRThe strategy applied to the dequeueing (output) processes when the queue is empty.xdA type synonym for the queue with static priorities applied when storing the elements in the queue.y=A type synonym for the SIRO (Serviced in Random Order) queue.zfA 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 .Signal when the  property value has changed.Signal when the  property value has changed.CReturn the load factor: the queue size divided by its maximum size. See also  and .Signal when the  property value has changed.Signal when the  property value has changed.PReturn the rate of the input items that were enqueued: how many items per time.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.ZReturn the rate of the output items that were actually 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 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.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.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  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.2Detect whether the item is contained in the queue.TDetect whether an item satisfying the specified predicate is contained in the queue.Clear the queue immediately.?Enqueue the item suspending the process if the queue is full. WEnqueue with the input priority the item suspending the process if the queue is full. YEnqueue with the storing priority the item suspending the process if the queue is full. eEnqueue with the input and storing priorities the item suspending the process if the queue is full.  Try to enqueue the item. Return # in the monad if the queue is full.:Try to enqueue with the storing priority the item. Return $ in the monad if the queue is full.NTry to enqueue the item. If the queue is full then the item will be lost and  will be returned.hTry to enqueue with the storing priority the item. If the queue is full then the item will be lost and  will be returned.ITry to enqueue the item. If the queue is full then the item will be lost.dTry to enqueue with the storing priority the item. If the queue is full then the item will be lost.HReturn a signal that notifies when the enqueuing operation is initiated.Return 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 , ` 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.Reset the statistics.|  '   s (tuvw ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;xyz{|}~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 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 item to search the queue forwhether the item was found the queue the predicatethe item if it was found the queue the queuethe item to enqueue the queuethe priority for inputthe item to enqueue the queuethe priority for storingthe item to enqueue the queuethe priority for inputthe priority for storingthe item to enqueue the queue the item which we try to enqueue the queuethe priority for storing the item which we try to enqueue the queue the item which we try to enqueue the queuethe priority for storing the item which we try to enqueue the queue the item which we try to enqueue the queuethe priority for storing the item which we try to enqueue  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 statisticsZstwvuxyz{|}~^{zyxstuvw|}~uvwt`  '   s (tuvw ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;xyz{|}~   ! " # $ % &&@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneC <-Stores the item and a time of its enqueuing. =Return the item value. >(Return the time of storing in the queue._Represents an infinite queue using the specified strategies for internal storing (in memory), sm, and dequeueing (output), so, where a0 denotes the type of items stored in the queue.AThe strategy applied when storing (in memory) items in the queue.:The strategy applied to the dequeueing (output) processes.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.#Create a new infinite FCFS queue. #Create a new infinite LCFS queue. #Create a new infinite SIRO queue. 'Create a new infinite priority queue. <Create a new infinite queue with the specified strategies.  Test whether the queue is empty. See also  and .Signal when the  property value has changed.Signal when the  property value has changed.Return the current queue size. See also ,  and .!Return the queue size statistics.Signal when the  property value has changed.Signal when the  property value has changed.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 .Signal when the  property value has changed.Signal when the  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.2Detect whether the item is contained in the queue.TDetect whether an item satisfying the specified predicate is contained in the queue.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. ADAccept the dequeuing request and return the current simulation time. B,Extract an item for the dequeuing request. CCA post action after extracting the item by the dequeuing request. DuUpdate 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.Reset the statistics.Q < E = > F G H I J K L M N O P Q R4the strategy applied when storing items in the queueQthe strategy applied to the dequeueing (output) processes when the queue is empty 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 item to search the queue forwhether the item was found the queue the predicatethe item if it was found 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 A the queuethe current time B the queue!the time of the dequeuing requestthe dequeued value C the queue!the time of the dequeuing requestthe item to dequeuethe dequeued value D the queue!the time of the dequeuing requestthe item and its input time%the action of updating the statistics:<? < E = > F G H I J K L M N O P Q R ? @ A B C D'@Copyright (c) 2009-2017, 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 X monad.Create a new reference. Read the value of a reference. %Write a new value into the reference. %Mutate the contents of the reference. HReturn a signal that notifies about every change of the reference state. HReturn a signal that notifies about every change of the reference state.  S T U                S T U     (@Copyright (c) 2009-2017, 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.Invert the gate.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. V W    V W)@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone2&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.0@Return the statistics for the utilisation count of the resource.1Signal triggered when the / property changes.2Signal triggered when the / property changes.30Return the current queue length of the resource.4;Return the statistics for the queue length of the resource.5Signal triggered when the 3 property changes.6Signal triggered when the 3 property changes.7+Return the total wait time of the resource.88Return the statistics for the wait time of the resource.9Signal triggered when the 7 and 8 properties change.:Signal triggered when the 7 and 8 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. X7Release the resource without affecting its utilisation.?WTry to request for the resource decreasing its count in case of success and returning  in the X monad; otherwise, returning .@rAcquire the resource, perform some action and safely release the resource in the end, even if the  was raised within the action. AAcquire the resource with the specified priority, perform some action and safely release the resource in the end, even if the  was raised within the action. Y)Decrease the count of available resource.BmIncrease the count of available resource by the specified number, invoking the awaiting processes as needed.C~Decrease the count of available resource by the specified number, waiting for the processes capturing the resource as needed.D;Signal triggered when one of the resource counters changes. Z-Update the resource count and its statistics. [9Update the resource utilisation count and its statistics. \4Update the resource queue length and its statistics. ]1Update the resource wait time and its statistics.EReset the statistics.E ^ _ ` a b c d e f g h i j k l m n o !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 indefinite#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 indefinite%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 indefinite'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 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 indefinite+,-./0123456789:;the requested resource<the requested resource the priority=the resource to release>the resource to release Xthe resource to release?(the resource which we try to request for@Dthe 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 actionAEthe 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 Y,the resource for which to decrease the countB the resource$the increment for the resource countC the resource$the decrement for the resource countD Z [ \ ]EF, !"#$%&'()*+,-./0123456789:;<=>?@ABCDE. !"#$%&'()*+,/03478;<?=>@ABCE-.12569:D2 ^ _ ` a b c d e f g h i j k l m n o !"#$%&'()*+,-./0123456789:;<=> X?@A YBCD Z [ \ ]EF*@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone& p'Idenitifies an item that was preempted. q3Idenitifies an item that requests for the resource. rQIdenitifies an awaiting item that waits for releasing of the resource to take it. s5Identifies an acting item that acquired the resource.G"Represents a preemptible resource.H0Return the maximum count of the resource, where - means that the resource has no upper bound.I\Create a new resource with the specified initial count that becomes the upper bound as well.JLCreate a new resource with the specified initial and maximum counts, where , means that the resource has no upper bound.K3Return the current available count of the resource.L>Return the statistics for the available count of the resource.MSignal triggered when the K property changes.NSignal triggered when the K property changes.O5Return the current utilisation count of the resource.P@Return the statistics for the utilisation count of the resource.QSignal triggered when the O property changes.RSignal triggered when the O property changes.S0Return the current queue length of the resource.T;Return the statistics for the queue length of the resource.USignal triggered when the S property changes.VSignal triggered when the S property changes.W+Return the total wait time of the resource.X8Return the statistics for the wait time of the resource.YSignal triggered when the W and X properties change.ZSignal triggered when the W and X 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. t{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  was raised within the action. u~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.a;Signal triggered when one of the resource counters changes. v-Update the resource count and its statistics. w4Update the resource queue length and its statistics. x9Update the resource utilisation count and its statistics. y1Update the resource wait time and its statistics.bReset the statistics.C p z { | } q ~  r s G H I9the initial count (and maximal count too) of the resourceJ!the initial count of the resource:the maximum count of the resource, which can be indefiniteKLMNOPQRSTUVWXYZ[the requested resource3the priority (the less value has a higher priority)\the resource to release tthe resource to release]Ethe 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 u^ the resource$the increment for the resource count_ the resource$the decrement for the resource count` the resourcea change of the resource counta v w x ybcdGHIJKLMNOPQRSTUVWXYZ[\]^_`abGHIJHKLOPSTWX[\]^_`bMNQRUVYZa' p z { | } q ~  r s G H IJKLMNOPQRSTUVWXYZ[\ t] u^_`a v w x ybcd+@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNonee4Represents an accumulator for the timing statistics.f"Return the accumulated statistics.gHStart gathering the timing statistics from the current simulation time. e fgefgegfe fg,@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneh"Represents the result of the task.iIthe task was successfully completed and it returned the specified resultj<the specified exception was raised when performing the task.kthe task was cancelledlEThe task represents a process that was already started in background.mTReturn an identifier for the process that was launched in background for this task. *It contains the result of the computation.nFReturn a signal that notifies about receiving the result of the task.o:Try to get the task result immediately without suspension.p@Return the task result suspending the outer process if required.qCancel the task.r$Test whether the task was cancelled. :Create a task by the specified process and its identifier.skRun the process with the specified identifier in background and return the corresponding task immediately.tLRun the process in background and return the corresponding task immediately.uEnqueue the process that will be started at the specified time with the given identifier from the event queue. It returns the corresponding task immediately.vEnqueue the process that will be started at the specified time from the event queue. It returns the corresponding task immediately.wpRun using the specified identifier a child process in background and return immediately the corresponding task.xPRun a child process in background and return immediately the corresponding task.ypRun using the specified identifier a child process in background and return immediately the corresponding task.zPRun a child process in background and return immediately the corresponding 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. hijkl m nopqr stuvwxyz{|}hijklnmopqrstuvwxyz{|}lmnhijkmopn{qrtsxwzyvu|}hijkl m nopqr stuvwxyz{|}-@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone ~ Like the L reference but keeps the history of changes in different time points. The ~K 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.Create a new variable.Read 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 c function passing in the % signal to it and then call function e.GReturn a signal that notifies about every change of the variable state.GReturn a signal that notifies about every change of the variable state.~  ~ ~ ~ .@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone  Like the L reference but keeps the history of changes in different time points. The K 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.Create a new variable.Read 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 c function passing in the % signal to it and then call function e.GReturn a signal that notifies about every change of the variable state.GReturn a signal that notifies about every change of the variable state.     /@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone:KRepresents an infinite stream of data in time, some kind of the cons cell.Run the stream.mCreate a stream that will use the specified process identifier. It can be useful to refer to the underlying V computation which can be passivated, interrupted, canceled and so on. See also the  function for more details.[Memoize the stream so that it would always return the same data within the simulation run.0Zip two streams trying to get data sequentially.aZip two streams trying to get data as soon as possible, launching the sub-processes in parallel.2Zip three streams trying to get data sequentially.cZip three streams trying to get data as soon as possible, launching the sub-processes in parallel.Unzip 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 .fTo form each new portion of data for the output stream, read data from the input streams in parallel.This is a generalization of .=Return a stream of values generated by the specified process.0Map the stream according the specified function.Compose the stream.EAccumulator that outputs a value determined by the supplied function.Sequential application.Sequential application.FFilter only those data values that satisfy to the specified predicate.FFilter only those data values that satisfy to the specified predicate.The stream of  values.The stream of  values. Replace the  values. Replace the  values.Partition the stream of   values into two streams.WSplit the input stream into the specified number of output streams after applying the , strategy for enqueuing the output requests.CSplit 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  that does namely this.USplit the input stream into a list of output streams using the specified priorities.eSplit the input stream into the specified number of output streams after filtering and applying the , strategy for enqueuing the output requests.SSplit the input stream into the specified number of output streams after filtering.JIf you don't know what the strategy to apply, then you probably need the  strategy, or function  that does namely this.+Concatenate the input streams applying the + strategy and producing one output stream.: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  that does namely this.CConcatenate the input priority streams producing one output stream.Merge two streams applying the ' strategy for enqueuing the input data.Merge two streams.JIf you don't know what the strategy to apply, then you probably need the  strategy, or function  that does namely this.Merge two priority streams.(An empty stream that never returns data.Consume 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.Sink 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.Prefetch 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.Like I but allows specifying an arbitrary queue instead of the unbounded queue.<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 md function to add the information about the time points at which the signal was actually received.The point is that the ! is requested outside, while the Ng 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 unbounded 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. Consider using ; that allows specifying the bounded queue in case of need.Return a computation of the disposable signal that triggers values from the specified stream, each time the next value of the stream is received within the underlying  computation.Transform 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.?Delay the stream by one step using the specified initial value.EReturn a stream consisting of exactly one element and inifinite tail.WRemoves 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 .<Return the suffix of the stream of elements remaining after .ECreate the specified number of equivalent clones of the input stream.TReturn a stream of first arrivals after assembling the specified number of elements.SReturn a stream of last arrivals after assembling the specified number of elements.;Assemble an accumulated stream using the supplied function.9Show the debug messages with the current simulation time.?6the strategy applied for enqueuing the output requeststhe number of output streamsthe input streamthe splitted output streams6the strategy applied for enqueuing the output requeststhe streams of prioritiesthe input streamthe splitted output streams6the strategy applied for enqueuing the output requeststhe filters for output streamsthe input streamthe splitted output streams1the strategy applied for enqueuing the input datathe input streamthe combined output stream1the strategy applied for enqueuing the input datathe input streamthe combined output stream1the strategy applied for enqueuing the input datathe fist input streamthe second input streamthe output combined stream1the strategy applied for enqueuing the input datathe fist input streamthe second input streamthe output combined streamenqueuedequeuethe input signalthe output streamthe request messagethe response messagea stream;;=0@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone/It allows representing a signal transformation.Run the channel transform.Return a delayed signal.This is actually the n function wrapped in the  type. Like ), but it re-computes the delay each time.This is actually the o function wrapped in the  type. Sink the signal. It returns a computation that subscribes to the signal and then ignores the received data. The resulting computation can be a moving force to simulate the whole system of the interconnected signals and channels.ZShow the debug message with the current simulation time, when emitting the output signal. the delaythe delay channel the delaythe delay channel1@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone*Represents a processor of simulation data.Run the processor.6A processor that never finishes its work producing an .Create a simple processor by the specified handling function that runs the discontinuous process for each input value to get the output.EAccumulator that outputs a value determined by the supplied function.JInvolve the computation with side effect when processing a stream of data.pCreate a processor that will use the specified process identifier. It can be useful to refer to the underlying V computation which can be passivated, interrupted, canceled and so on. See also the  function for more details.vLaunches 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  that does namely this.XLaunches the specified processors in parallel using priorities for combining the output.XLaunches the specified processors in parallel using priorities for consuming the intput.qLaunches the specified processors in parallel using priorities for consuming the input and combining the output.Launches 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./Launches the processors sequentially using the O between them to model an autonomous work of each of the processors specified.Create 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.Like  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.=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  which this function is based on. In case of need, you can even write your own function from scratch. It is quite easy actually.Like  creates a queue processor but with a loop when some items can be processed and then added to the queue again. Also it allows specifying how two input streams of data can be merged.Like < creates a queue processor with a loop when 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.Like  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.This 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.IConvert the specified signal transform, i.e. the channel, to a processor.dThe processor may return data with delay as the values are requested by demand. Consider using the ml function to provide with the information about the time points at which the signal was actually triggered.The point is that the  used in the # is requested outside, while the N used in the h is triggered inside. They are different by nature. The former is passive, while the latter is active.The resulting processor may be a root of space leak as it uses an internal queue to store the values received from the input signal. Consider using ; that allows specifying the bounded queue in case of need.IConvert the specified processor to a signal transform, i.e. the channel. dThe processor may return data with delay as the values are requested by demand. Consider using the ml function to provide with the information about the time points at which the signal was actually triggered.The point is that the  used in the # is requested outside, while the N used in the g is triggered inside. They are different by nature. The former is passive, while the latter is active.The resulting channel may be a root of space leak as it uses an internal queue to store the values received from the input stream. Consider using ; that allows specifying the bounded queue in case of need.Like i but allows specifying an arbitrary queue for storing the signal values, for example, the bounded queue.Like i but allows specifying an arbitrary queue for storing the signal values, for example, the bounded queue.yA 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.#1the strategy applied for enqueuing the input data2the strategy applied for enqueuing the output datathe processors to parallelizethe parallelized processor1the strategy applied for enqueuing the input data2the strategy applied for enqueuing the output datathe processors to parallelizethe parallelized processor1the strategy applied for enqueuing the input data2the strategy applied for enqueuing the output dataBthe streams of input priorities and the processors to parallelizethe parallelized processor1the strategy applied for enqueuing the input data2the strategy applied for enqueuing the output dataBthe streams of input priorities and the processors to parallelizethe parallelized processor(a separate process to consume the input the resulting stream of data.consume two streams: the input values of type a and the values of type c returned by the loop*the stream of data that may become results,process and then decide what values of type 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)ienqueue the input item and wait while the queue is full if required so that there were no hanging itemsdequeue an output itemthe buffering processor,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 processorienqueue 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 processorienqueue 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 processorenqueuedequeue the channel the processorenqueuedequeue the processor the channelthe request messagethe response message a processor!2@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneJ 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 X` 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 events 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   the request messagethe response message a circuit          #       3@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone6Represents the net as an automaton working within the  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 V 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+,- !"#$%&'()*'() !"%&#$* !"#$%&'()*+,-4@Copyright (c) 2009-2017, 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.0uWhen processing every input element, hold the process for a random time interval having the triangular distribution.1gWhen processing every input element, hold the process for a random time interval distributed normally.2tWhen processing every input element, hold the process for a random time interval having the lognormal distribution.3When processing every input element, hold the process for a random time interval distributed exponentially with the specified mean (the reciprocal of the rate).4When 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.5When processing every input element, hold the process for a random time interval having the Poisson distribution with the specified mean.6When processing every input element, hold the process for a random time interval having the binomial distribution with the specified probability and trials.7When processing every input element, hold the process for a random time interval having the Gamma distribution with the specified shape and scale.8When processing every input element, hold the process for a random time interval having the Beta distribution with the specified shape parameters (alpha and beta).9When 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 interval0the minimum time intervalthe median of the time intervalthe maximum time interval1the mean time intervalthe time interval deviation2Jthe mean of a normal distribution which this distribution is derived fromOthe deviation of a normal distribution which this distribution is derived from33the mean time interval (the reciprocal of the rate)4&the scale (the reciprocal of the rate) the shape5the mean time interval6the probabilitythe number of trials7 the shape$the scale (a reciprocal of the rate)8 shape (alpha) shape (beta)9shapescale:)the discrete probability density function ./0123456789: ./0123456789: ./0123456789:5@Copyright (c) 2009-2017, 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).AWhen 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.BWhen processing every input element, hold the process for a random time interval having the Poisson distribution with the specified mean.CWhen processing every input element, hold the process for a random time interval having the binomial distribution with the specified probability and trials.DWhen processing every input element, hold the process for a random time interval having the Gamma distribution with the specified shape and scale.EWhen processing every input element, hold the process for a random time interval having the Beta distribution with the specified shape parameters (alpha and beta).FWhen processing every input element, hold the process for a random time interval having the Weibull distribution with the specified shape and scale.G}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 deviation?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)A&the scale (the reciprocal of the rate) the shapeBthe mean time intervalCthe probabilitythe number of trialsD the shape$the scale (a reciprocal of the rate)E shape (alpha) shape (beta)FshapescaleG)the discrete probability density function ;<=>?@ABCDEFG ;<=>?@ABCDEFG ;<=>?@ABCDEFG6@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneHRepresents 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.ILike H 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.HIHIHIHI7@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneGJIt models a server that takes a and provides b having state s.K 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.L,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.M,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.N8Create a new preemptible server that can provide output b by input a.O8Create a new preemptible server that can provide output b by input a starting from state s.P,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 ; function which separates the processors with help of the < 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.Q'Return the current state of the server. See also R and S.RSignal when the Q property value has changed.SSignal when the Q property value has changed.TRReturn 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 U and V.USignal when the T property value has changed.VSignal when the T property value has changed.WMReturn 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 X and Y.XSignal when the W property value has changed.YSignal when the W property value has changed.Z]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 Z property value has changed.\Signal when the Z 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 a and b.aSignal when the ` property value has changed.bSignal when the ` property value has changed.cQReturn 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 d and e.dSignal when the c property value has changed.eSignal when the c property value has changed.fbReturn 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 g and h.gSignal when the f property value has changed.hSignal when the f property value has changed.iqReturn 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 j and k.jSignal when the i property value has changed.kSignal when the i property value has changed.lwIt 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 m and n.mSignal when the l property value has changed.nSignal when the l property value has changed.o|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 p and q.pSignal when the o property value has changed.qSignal when the o property value has changed.rIt 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 s and t.sSignal when the r property value has changed.tSignal when the r property value has changed.uIt 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 v and w.vSignal when the u property value has changed.wSignal when the u property value has changed.x1Raised when the server receives a new input task.y.Raised when the task processing was preempted.zSRaised 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.Reset the statistics.HJ K L(provide an output by the specified inputMEprovide a new state and output by the specified old state and inputthe initial stateN+whether the server process can be preempted(provide an output by the specified inputO+whether the server process can be preemptedEprovide a new state and output by the specified old state and inputthe initial stateP QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~6JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~7JKLMNOPKQTWZ]`cfiloru~RSUVXY[\^_abdeghjkmnpqstvwxyz{|}6J K LMNOP QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~8@Copyright (c) 2009-2017, 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 function9@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone PAccumulates 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.fReturn a signal that actually measures how much time has passed from the time of arriving the events.Note that the statistics is counted each time you subscribe to the output signal. For example, if you subscribe twice then the statistics counting is duplicated. Ideally, you should subscribe to the output signal only once.Like \ but measures how much time has passed from the time of arriving the events in the channel.Reset the statistics.    :@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneFReturn a signal of random events that arrive with the specified delay.=Create a new signal with random delays distributed uniformly.ECreate a new signal with integer random delays distributed uniformly.JCreate a new signal with random delays having the triangular distribution.<Create a new signal with random delays distributed normally.ICreate a new signal with random delays having the lognormal distribution.vReturn a new signal with random delays distibuted exponentially with the specified mean (the reciprocal of the rate).Return a new signal with random delays having the Erlang distribution with the specified scale (the reciprocal of the rate) and shape parameters.`Return a new signal with random delays having the Poisson distribution with the specified mean.sReturn a new signal with random delays having the binomial distribution with the specified probability and trials.gReturn a new signal with random delays having the Gamma distribution by the specified shape and scale.xReturn a new signal with random delays having the Beta distribution by the specified shape parameters (alpha and beta).iReturn a new signal with random delays having the Weibull distribution by the specified shape and scale.RReturn a new signal with random delays having the specified discrete distribution..compute a pair of the delay and event of type aAthe computation that returns a signal emitting the delayed eventsthe minimum delaythe maximum delayJthe computation of signal emitting random events with the delays generatedthe minimum delaythe maximum delayJthe computation of signal emitting random events with the delays generatedthe minimum delaythe median of the delaythe maximum delayJthe computation of signal emitting random events with the delays generatedthe mean delaythe delay deviationJthe computation of signal emitting random events with the delays generatedJthe mean of a normal distribution which this distribution is derived fromOthe deviation of a normal distribution which this distribution is derived fromJthe computation of signal emitting random events with the delays generated+the mean delay (the reciprocal of the rate)Jthe computation of signal emitting random events with the delays generated&the scale (the reciprocal of the rate) the shapeJthe computation of signal emitting random events with the delays generatedthe mean delayJthe computation of signal emitting random events with the delays generatedthe probabilitythe number of trialsJthe computation of signal emitting random events with the delays generated the shape$the scale (a reciprocal of the rate)Jthe computation of signal emitting random events with the delays generatedthe shape (alpha)the shape (beta)Jthe computation of signal emitting random events with the delays generatedshapescaleJthe computation of signal emitting random events with the delays generated)the discrete probability density functionJthe computation of signal emitting random events with the delays generated;@Copyright (c) 2009-2017, 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 generatedthe minimum delaythe median of the delaythe maximum delay5the stream of random events with the delays generatedthe mean delaythe delay deviation5the stream of random events with the delays generatedJthe 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 generatedthe mean delay5the stream of random events with the delays generatedthe 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 generatedthe shape (alpha)the shape (beta)5the stream of random events with the delays generatedshapescale5the stream of random events with the delays generated)the discrete probability density function5the stream of random events with the delays generated<@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneRepresents 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.Add 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.Create a new state.Create a child state.Create an agent.!Return the selected active state.lSelect the state. The activation and selection are repeated while there is the transition state defined by .7Set the activation computation for the specified state.9Set the deactivation computation for the specified state.sSet the transition state which will be next and which is used only when selecting the state directly with help of o. If the state was activated intermediately, when selecting another state, then this computation is not used. 0Trigger the signal when the agent state changes.GReturn a signal that notifies about every change of the selected state.GReturn a signal that notifies about every change of the selected state.$           =@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone:Like J" 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. "The current state of the activity. Provide b by specified a. #Whether the process is preemptible. 1The counted total time of utilising the activity. 2The counted total time when the activity was idle. 8The counted total time when the activity was preempted. (The statistics for the utilisation time. 7The statistics for the time when the activity was idle. <The statistics for the time when the activity was preempted. 6A signal raised when starting to utilise the activity. 4A signal raised when the activity has been utilised. 3A signal raised when the utilisation was preempted. WA 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.8Return 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. ?Process the input with ability to handle a possible preemption.)Return the current state of the activity. See also  and .Signal when the  property value has changed.Signal when the  property value has changed.=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  and .Signal when the  property value has changed.Signal when the  property value has changed.9Return 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  and .Signal when the  property value has changed.Signal when the  property value has changed.aReturn 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  and .Signal when the  property value has changed.Signal when the  property value has changed.BReturn 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  and .Signal when the  property value has changed.Signal when the  property value has changed.>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  and .Signal when the  property value has changed.Signal when the  property value has changed.gReturn 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  and .Signal when the  property value has changed.Signal when the  property value has changed.aIt 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  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 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  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 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.ORaised when the activity has been utilised after the current task is processed.3Raised when the activity utilisation was preempted.WRaised when the activity utilisation was proceeded after it had been preempted earlier.5Signal whenever any property of the activity changes.bReturn the summary for the activity with desciption of its properties using the specified indent.Reset the statistics.;  (provide an output by the specified inputEprovide 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 state ,-,   >@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneCreate 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.Create 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.Create 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.Create 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.Create 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.Create 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.Create 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.Create 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.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.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.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.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.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.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation.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.By default, it is assumed that the activity process cannot be preempted, because the handling of possible task preemption is rather costly operation. Create 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. Create a new activity that holds the process for a random time interval distributed uniformly, when processing every input element. Create a new activity that holds the process for a random time interval distributed uniformly, when processing every input element. Create a new activity that holds the process for a random time interval having the triangular distribution, when processing every input element. Create a new activity that holds the process for a random time interval distributed normally, when processing every input element.Create a new activity that holds the process for a random time interval having the lognormal distribution, when processing every input element.Create 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.Create 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.Create 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.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 activity process can be preemptedthe minimum time intervalthe maximum time interval -whether the activity process can be preemptedthe minimum time intervalthe maximum time interval -whether the activity process can be preemptedthe minimum time intervalthe median of the time intervalthe maximum time interval -whether the activity process can be preemptedthe mean time intervalthe time interval deviation-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 from-whether the activity process can be preempted3the mean time interval (the reciprocal of the rate)-whether the activity process can be preempted&the scale (the reciprocal of the rate) the shape-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 function               ?@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone*Like J" it models an activity that takes a and provides bd. But unlike the former this kind of activity has no state. Also it is destined to be used within  computations. Provide b by specified a. #Whether the process is preemptible. )The start time of creating the operation. 2The last time of utilising the operation activity. 1The counted total time of utilising the activity. 8The counted total time when the activity was preempted. (The statistics for the utilisation time. <The statistics for the time when the activity was preempted. 6A signal raised when starting to utilise the activity. 4A signal raised when the activity has been utilised. 3A signal raised when the utilisation was preempted. WA signal raised when the utilisation was proceeded after it had been preempted earlier./Create a new operation 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 operation that can provide output b by input a.OReturn a computation for the specified operation. It updates internal counters.@The computation can be used only within one process at any time. ?Process the input with ability to handle a possible preemption.GReturn the counted total time when the operation activity was utilised.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.kReturn the counted total time when the operation 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  and  .Signal when the  property value has changed. Signal when the  property value has changed.!LReturn the statistics for the time when the operation activity was utilised.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 for the time when the operation 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 % 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 operation activity was utilised since the time of creating the operation.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.*It returns the factor changing from 0 to 1, which estimates how often the operation activity was preempted waiting for the further proceeding since the time of creating the operation.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.-ZRaised when starting to utilise the operation activity after a new input task is received..YRaised when the operation activity has been utilised after the current task is processed./=Raised when the operation activity utilisation was preempted.0aRaised when the operation activity utilisation was proceeded after it had been preempted earlier.16Signal whenever any property of the operation changes.2cReturn the summary for the operation with desciption of its properties using the specified indent.3Reset the statistics.+ (provide an output by the specified input%whether the activity can be preempted(provide an output by the specified input  !"#$%&'()*+,-./0123 !"#$%&'()*+,-./0123!$'*32 "#%&()+,-./01   !"#$%&'()*+,-./0123@@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone4Create a new operation that holds the process for a random time interval distributed uniformly, when processing every input element.By default, it is assumed that the operation process cannot be preempted, because the handling of possible task preemption is rather costly.5Create a new operation that holds the process for a random time interval distributed uniformly, when processing every input element.By default, it is assumed that the operation process cannot be preempted, because the handling of possible task preemption is rather costly.6Create a new operation 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 operation process cannot be preempted, because the handling of possible task preemption is rather costly.7Create a new operation that holds the process for a random time interval distributed normally, when processing every input element.By default, it is assumed that the operation process cannot be preempted, because the handling of possible task preemption is rather costly.8Create a new operation 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 operation process cannot be preempted, because the handling of possible task preemption is rather costly.9Create a new operation 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 operation process cannot be preempted, because the handling of possible task preemption is rather costly.:Create a new operation 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 operation process cannot be preempted, because the handling of possible task preemption is rather costly.;Create a new operation 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 operation process cannot be preempted, because the handling of possible task preemption is rather costly.<Create a new operation 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 operation process cannot be preempted, because the handling of possible task preemption is rather costly.=Create a new operation 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 operation process cannot be preempted, because the handling of possible task preemption is rather costly.>Create a new operation 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 operation process cannot be preempted, because the handling of possible task preemption is rather costly.?Create a new operation 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 operation process cannot be preempted, because the handling of possible task preemption is rather costly.@Create a new operation 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 operation process cannot be preempted, because the handling of possible task preemption is rather costly.ACreate a new operation that holds the process for a random time interval distributed uniformly, when processing every input element.BCreate a new operation that holds the process for a random time interval distributed uniformly, when processing every input element.CCreate a new operation that holds the process for a random time interval having the triangular distribution, when processing every input element.DCreate a new operation that holds the process for a random time interval distributed normally, when processing every input element.ECreate a new operation that holds the process for a random time interval having the lognormal distribution, when processing every input element.FCreate a new operation 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.GCreate a new operation 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.HCreate a new operation that holds the process for a random time interval having the Poisson distribution with the specified mean, when processing every input element.ICreate a new operation that holds the process for a random time interval having the binomial distribution with the specified probability and trials, when processing every input element.JCreate a new operation that holds the process for a random time interval having the Gamma distribution with the specified shape and scale, when processing every input element.KCreate a new operation 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.LCreate a new operation that holds the process for a random time interval having the Weibull distribution with the specified shape and scale, when processing every input element.MCreate a new operation that holds the process for a random time interval having the specified discrete distribution, when processing every input element.4the minimum time intervalthe maximum time interval5the minimum time intervalthe maximum time interval6the minimum time intervalthe median of the time intervalthe maximum time interval7the mean time intervalthe time interval deviation8Jthe mean of a normal distribution which this distribution is derived fromOthe deviation of a normal distribution which this distribution is derived from93the mean time interval (the reciprocal of the rate):&the scale (the reciprocal of the rate) the shape;the mean time interval<the probabilitythe number of trials= the shape$the scale (a reciprocal of the rate)> shape (alpha) shape (beta)?shapescale@)the discrete probability density functionA.whether the operation process can be preemptedthe minimum time intervalthe maximum time intervalB.whether the operation process can be preemptedthe minimum time intervalthe maximum time intervalC.whether the operation process can be preemptedthe minimum time intervalthe median of the time intervalthe maximum time intervalD.whether the operation process can be preemptedthe mean time intervalthe time interval deviationE.whether the operation 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 fromF.whether the operation process can be preempted3the mean time interval (the reciprocal of the rate)G.whether the operation process can be preempted&the scale (the reciprocal of the rate) the shapeH.whether the operation process can be preemptedthe mean time intervalI.whether the operation process can be preemptedthe probabilitythe number of trialsJ.whether the operation process can be preempted the shape the scaleK.whether the operation process can be preempted shape (alpha) shape (beta)L.whether the operation process can be preemptedshapescaleM.whether the operation process can be preempted)the discrete probability density function456789:;<=>?@ABCDEFGHIJKLM456789:;<=>?@ABCDEFGHIJKLM456789:;<=>?@ABCDEFGHIJKLMA@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNoneoNThe result entity identifier.OA 8 computation.PDescribes a vector.Q5Describes a vector item with the specified subscript.RA T value.S Property V.T Property W.U Property X.V Property Y.W Property Z.X Property \.Y Property ].ZA : value.[ Property <.\ Property =.]A D value.^ Property F._ Property G.` Property H.a Property A.b Property C.c Property b.d Property J.e Property K.f Property L.g Property M.h Property N.i Property O.jA 6 value.k Property 8.l Property 9.m A finite s.n An infinite .o Property u.p Property v.q Property w.r Property .s Property .t Property t.u Property .v Property .w Property .x Property .y Property .z Property .{ Property .| Property .} Property .~ Property . Property . Property . Property . Property . Property . Property . Property .An . Property . Represents a J. Property K. Property Q. Property T. Property W. Property Z. Property ]. Property `. Property c. Property f. Property i. Property l. Property o. Property r. Property u.Represents an . Property . Property . Property . Property . Property . Property . Property . Property . Property . Property . Property . Represents a . Property +. Property ,. Property /. Property 0. Property 3. Property 4. Property 7. Property 8.Represents an . Property . Property . Property !. Property $. Property '. Property *.An user defined description.$A localised property or object name.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.oNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~oNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~oNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ NfOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~B@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone9:;AT1Represents 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.There is no signal at all.7The signal is unknown, but the entity probably changes.'When the signal is precisely specified.;When the specified signal was combined with unknown signal.'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. 2Try to return statistics based on integer numbers. 9Try to return timing statistics based on integer numbers. ,Try to return double numbers in time points. 6Try to return lists of double numbers in time points.  1Try to return statistics based on double numbers. 9Try to return timing statistics based on integer numbers.4Try to return string representations in time points.4The simulation results represented by a single item.Encapsulates the result source.'The source consisting of a single item.An object-like source.A vector-like structure.This is a separator text.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. XReturn the source of simulation results by the specified name, identifier and provider. @A name used for indentifying the results when generating output.bTry to return a version optimised for fast aggregation of the statistics based on integer numbers.pTry to return a version optimised for fast aggregation of the statistics based on double floating point numbers.&Return integer numbers in time points.0Return lists of integer numbers in time points. +Return statistics based on integer numbers. [Return a version optimised for fast aggregation of the statistics based on integer numbers.!2Return timing statistics based on integer numbers."%Return double numbers in time points.#/Return lists of double numbers in time points. $*Return statistics based on double numbers.%iReturn a version optimised for fast aggregation of the statistics based on double floating point numbers.&2Return timing statistics based on integer numbers.'-Return string representations in time points.(BCalculate the result vector signal and memoize it in a new vector.)CCalculate the result vector summary and memoize it in a new vector. Transform the result value.*8Create a new property source by the specified container.+6Create a constant property by the specified container.,{Create by the specified container a property that changes in the integration time points, or it is supposed to be such one.--Create a property by the specified container..bCreate by the specified container a mapped property which is recomputed each time again and again./NConvert the result value to a container with the specified object identifier. 0(Convert the result container to a value. SConvert the timing statistics data to its normalised sampling-based representation.1DConstruct a new result signal by the specified optional pure signal. Flatten the result source. Return the result source name. `Expand the result source returning a more detailed version expanding the properties as possible. Return a summarised and usually more short version of the result source expanding the main properties or excluding auxiliary properties if required. &Return a signal emitted by the source.2/Represent the result source as integer numbers.38Represent the result source as lists of integer numbers.4CRepresent the result source as statistics based on integer numbers.5fRepresent the result source as statistics based on integer numbers and optimised for fast aggregation.6JRepresent the result source as timing statistics based on integer numbers.7=Represent the result source as double floating point numbers.8FRepresent the result source as lists of double floating point numbers.9QRepresent the result source as statistics based on double floating point numbers.:tRepresent the result source as statistics based on double floating point numbers and optimised for fast aggregation.;XRepresent the result source as timing statistics based on double floating point numbers.<-Represent the result source as string values.=ACreate the predefined signals provided by every simulation model.>Prepare the simulation results.?)Represent the results as integer numbers.@2Represent the results as lists of integer numbers.A=Represent the results as statistics based on integer numbers.B`Represent the results as statistics based on integer numbers and optimised for fast aggregation.CDRepresent the results as timing statistics based on integer numbers.D7Represent the results as double floating point numbers.E@Represent the results as lists of double floating point numbers.FKRepresent the results as statistics based on double floating point numbers.GnRepresent the results as statistics based on double floating point numbers and optimised for fast aggregation.HRRepresent the results as timing statistics based on double floating point numbers.I'Represent the results as string values.J1Return a signal emitted by the specified results.KReturn 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.LReturn a short version of the simulation results, i.e. their summary, expanding the main properties or excluding auxiliary properties if required.MTake a result by its name.N}Take a result from the object with the specified property label, but it is more preferrable to refer to the property by its N identifier with help of the O function.OTake a result from the object with the specified identifier. It can identify an item, object property, the object iself, vector or its elements.P=Take a result from the vector by the specified integer index.Q@Take a result from the vector by the specified string subscript.R@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.SReturn 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.TLReturn 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. )Return a source by the specified counter. )Return a source by the specified counter. )Return a source by the specified counter. )Return a source by the specified counter. .Return a source by the specified finite queue. 1Return the summary by the specified finite queue. 0Return a source by the specified infinite queue. 3Return the summary by the specified infinite queue. /Return a source by the specified arrival timer. 2Return the summary by the specified arrival timer. (Return a source by the specified server. +Return the summary by the specified server. *Return a source by the specified activity. +Return a summary by the specified activity. *Return a source by the specified resource. +Return a summary by the specified resource. *Return a source by the specified resource. +Return a summary by the specified resource. +Return a source by the specified operation. ,Return a summary by the specified operation.U/Return an arbitrary text as a separator source.V'Return the source of the modeling time. Make an integer subscript        !"#$%&'() * the containerthe property labelthe property identifier)get the specified data from the container&get the data signal from the container+ the containerthe property labelthe property identifier)get the specified data from the container, the containerthe property labelthe property identifier)get the specified data from the container- the containerthe property labelthe property identifier)get the specified data from the container*get a signal triggered when changing data.. the containerthe property labelthe property identifierrecompute the specified data/0 1 23456789:;<=>?@ABCDEFGHIJKLMNOPQR STthe result namethe result identifierthe result computation the statistics the statistics the statistics the statistics  the counter  the counter  the counter  the counter the queue container the queue container the queue container the queue container the arrival timer container the arrival timer container the server container the server container the activity container the activity container the resource container the resource container the resource container the resource container the operation container the operation containerUV WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV>KLMNOPQ?@ABCDEFGHI=JS      !"#$%&'()*+,-./01UV23456789:;<RT       !"#$%&'() *+,-./0 1 23456789:;<=>?@ABCDEFGHIJKLMNOPQR ST          UV WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~C@Copyright (c) 2009-2017, 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 X/ computation synchronized with the event queue.AThis is a function that shows the simulation results within the X/ 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 localisation a handle an indenta labela localisation an indenta localisationa handlea localisationa localisation an indenta localisation  an indenta labela localisationa localisation$$&  D@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone9;b5It models an opreation which actvity can be utilised.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.0;Return the statistics for the queue length of the resource.1+Return the total wait time of the resource.28Return the statistics for the wait time of the resource.3GReturn the counted total time when the operation activity was utilised.4kReturn the counted total time when the operation activity was preemted waiting for the further proceeding.5LReturn the statistics for the time when the operation activity was utilised.6qReturn the statistics for the time when the operation activity was preempted waiting for the further proceeding.7kIt returns the factor changing from 0 to 1, which estimates how often the operation activity was utilised.8It returns the factor changing from 0 to 1, which estimates how often the operation activity was preempted waiting for the further proceeding.v      !"#$%&'()*+,-./0123456789:;<=>?@ABl      !"#$%&'()*+,-./012345678l      !"#$%&'()*+,-./012345678k      !"#$%&'()*+,-./0123456789:;<=>?@ABL@Copyright (c) 2009-2017, David Sorokin <david.sorokin@gmail.com>BSD3'David Sorokin <david.sorokin@gmail.com> experimentalNone6789:;<=>AC?@BDEFGHJKLMNOIPQRSTUVWXYZ[\]^_`abcdefghijklmnop   +,-/012345689:;<JKLMNOPQRSTUVWXZ[\^_`abcdfghijklmn     6789:;<=HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopy      !"#$%&'()     efghijklmnopqrstuvwxyz{|}      !"#$%&'()*./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnMNOPQRSTUVWXYZ[\]^opqqrsttuvwxyz{|}}~                                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 6 7 7 8 8 9 : ; ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p p q r s t u v w x y z { | } } ~                                       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abbcdefgghijklmnopqrstuvwxyz{|}~                        ! " # $!%!&!'!(!)!*!+!,!-!.!/!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#A#D#E##,#.#/#F#G#H#I#####K#L##M##N###O##Q$%$'$4$5$6$8$9$=$>$?$U$V$@%A%B%C%D%E%%,%.%/%F%G%H%I%%%W%X%J%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%{%|%}%~%%%%%%K%L%%M%%N%%%O%%P%Q%R%S%T%%%%%%%%%%%%%&A&D&E&&,&.&/&F&G&H&I&&&W&X&&[&\&]&d&e&f&g&h&i&j&k&l&q&r&s&t&u&v&}&~&&&&&&K&L&&M&&N&&&O&&Q&&&&&&'''''''(((((((((((()%)&)')()))*)+),)-).)/)0)1)2)3)4)5)6))))))))))))))))7)8)9):);)<)=)>)?)))@*%*'*4*5*6****************8*9*=*>*?*U***V*@+++,,,,,,,,,,,,,,,,,,,,,,---------.........///////////////////////////////////////////////////////// / / / / //0000000011111111111 1!1"1#1$1%1&1'1(1)1*1+1,1-1.1/10111213141516171829292:2;2<2=2>2?2@2A2B2C2D2E2F2G2H2I2J2K2L2M2N2O2P2Q2R2S2T2U2V2W2X3Y3Y3Z3[3\3]3^3_3`3a3b3c3d3e3f3g3h3i3j4k4l4m4n4o4p4q4r4s4t4u4v4w5x5y5z5{5|5}5~5555556677777777777777777777777777777777777777777777777777777788888888888888888888888888999999999::::::::::::::;;;;;;;;;;;;;;<<<<<<<<<<<<<< < < < < =================== =!="=#=$=%=&='=(=)=*=+=,=-=.=/=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@{@|@}@~@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBB B B B B BBBBBBBBBBBBBBBBBBBBBBBB B!B"B#B$B%B&B&B'B(B)B*B*B+B,B-B.B/B0B1B2B3B4B5B6B7B8B9B:B;B<B=B>B?B@B@BABBBCBDBEBFBGBHBIBJBKBLBMBNBOBPBQBRBSBTBUBVBWBXBYBZB[B\B]B^B_B`BaBbBcBdBeBfBgBhBiBjBkBlBmBnBoBpBqBrBsBtBuBvBwBxByBzB{B|B}B~BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDTDTD%D%DDDDDDDADADqDqD}D}DtDtDDDDDDDDDDDDuDvD~DDDzD|DDDDDDDDrDsDCDDDEDDJDBDD[D^DaDdDgDjDmDpDqDrDsDtDwDzD}DDDDDDDDDDDDDDDDDDDDDD!D$D'D*D-D0D6DDDDDDDDXD[D^DaDdDgDDDDDDDDDD M     M    A !"#$%&'()*+,-./01 2 3456478 9 : ; < = > ? @ A B C D E F G H I J K L M r N O P @ Q F4RST4UV4UWX4YZ4Y[\]^_`ab cdebfghRijklmneopiqrjsituvwxyz{|}~t449:E4!%!!"""""A""""#####A###$$$$$$$$$$$$$$$$$%$$$%%%%%%%%%%%%%%%A%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&A&&&&&&&&&&&&''T'(()))))))))))%)))))))))))))***********************%**************++,,,-----.....4Y44222277777777777777 7 7 7 799 9<<<<<<<<<<<<<<<<<<== =!="=#=$=%=&='=(=)=*=+=,=?-?.?/?0?1?2?3?4?5?6?7?8?9?TB:B;B<B=B>B?B@BABBBCBDBEBFBGBHBIBJBKBLBMBNBOBPBQBRBSBTBUBVBWBXBYBZB[B C\C]^!aivika-5.2-AKnZe30vW5E71yk1kVzR0zSimulation.Aivika.VectorSimulation.Aivika.Unboxed Simulation.Aivika.Vector.UnboxedSimulation.Aivika.TableSimulation.Aivika.Statistics$Simulation.Aivika.PriorityQueue.PureSimulation.Aivika.PriorityQueueSimulation.Aivika.Generator Simulation.Aivika.Internal.Specs$Simulation.Aivika.Internal.Parameter%Simulation.Aivika.Internal.Simulation#Simulation.Aivika.Internal.Dynamics Simulation.Aivika.Internal.EventSimulation.Aivika.Ref.Base"Simulation.Aivika.Internal.Arrival Simulation.Aivika.Dynamics.ExtraSimulation.Aivika.Dynamics.Memo'Simulation.Aivika.Dynamics.Memo.Unboxed!Simulation.Aivika.Dynamics.Random Simulation.Aivika.SystemDynamics"Simulation.Aivika.Parameter.RandomSimulation.Aivika.Transform Simulation.Aivika.Transform.Memo!Simulation.Aivika.Transform.Extra(Simulation.Aivika.Transform.Memo.Unboxed"Simulation.Aivika.DoubleLinkedListSimulation.Aivika.QueueStrategySimulation.Aivika.CompositeSimulation.Aivika.SignalSimulation.Aivika.Internal.Cont"Simulation.Aivika.Internal.Process Simulation.Aivika.Process.RandomSimulation.Aivika.Resource.BaseSimulation.Aivika.Queue.Base%Simulation.Aivika.Queue.Infinite.Base*Simulation.Aivika.Resource.Preemption.BaseSimulation.Aivika.Queue Simulation.Aivika.Queue.InfiniteSimulation.Aivika.RefSimulation.Aivika.GateSimulation.Aivika.Resource%Simulation.Aivika.Resource.Preemption(Simulation.Aivika.Statistics.AccumulatorSimulation.Aivika.TaskSimulation.Aivika.VarSimulation.Aivika.Var.UnboxedSimulation.Aivika.StreamSimulation.Aivika.ChannelSimulation.Aivika.ProcessorSimulation.Aivika.CircuitSimulation.Aivika.NetSimulation.Aivika.Net.Random"Simulation.Aivika.Processor.Random'Simulation.Aivika.Processor.RoundRobbinSimulation.Aivika.ServerSimulation.Aivika.Server.RandomSimulation.Aivika.ArrivalSimulation.Aivika.Signal.RandomSimulation.Aivika.Stream.RandomSimulation.Aivika.AgentSimulation.Aivika.Activity!Simulation.Aivika.Activity.RandomSimulation.Aivika.Operation"Simulation.Aivika.Operation.Random Simulation.Aivika.Results.LocaleSimulation.Aivika.ResultsSimulation.Aivika.Results.IO#Simulation.Aivika.Results.TransformSimulation.Aivika.ParameterSimulation.Aivika.SimulationSimulation.Aivika.SpecsSimulation.Aivika.EventSimulation.Aivika.DynamicsSimulation.Aivika.ContSimulation.Aivika.ProcessSimulation.AivikaVector newVector copyVector vectorCount appendVector readVector writeVectorvectorBinarySearch freezeVector vectorInsertvectorDeleteAtvectorDeleteRange vectorIndex vectorIndexBy vectorDeletevectorDeleteByvectorContainsvectorContainsByUnboxednewUnboxedArray_$fUnboxedWord64$fUnboxedInt64$fUnboxedWord32$fUnboxedWord16$fUnboxedWord8 $fUnboxedWord$fUnboxedInt32$fUnboxedInt16 $fUnboxedInt8 $fUnboxedInt$fUnboxedFloat$fUnboxedDouble $fUnboxedChar $fUnboxedBool tableLookuptableLookupStepwise TimingCountertimingCounterValuetimingCounterStatsSamplingCountersamplingCounterValuesamplingCounterStats TimingDataemptyTimingStatsaddTimingStatstimingStatsMeantimingStatsMean2timingStatsVariance TimingStatstimingStatsCounttimingStatsMintimingStatsMaxtimingStatsLasttimingStatsMinTimetimingStatsMaxTimetimingStatsStartTimetimingStatsLastTimetimingStatsSumtimingStatsSum2 SamplingDataemptySamplingStatsaddSamplingStatscombineSamplingStats SamplingStatssamplingStatsCountsamplingStatsMinsamplingStatsMaxsamplingStatsMeansamplingStatsMean2combineSamplingStatsEithersamplingStatsVariancesamplingStatsDeviationreturnSamplingStatslistSamplingStatsfromIntSamplingStatssamplingStatsSummarytimingStatsDeviationreturnTimingStatsfromIntTimingStatsnormTimingStatstimingStatsSummaryemptySamplingCounterincSamplingCounterdecSamplingCountersetSamplingCounterreturnSamplingCounteremptyTimingCounterincTimingCounterdecTimingCountersetTimingCounterreturnTimingCounter$fBinaryTimingCounter$fNFDataTimingCounter$fBinarySamplingCounter$fNFDataSamplingCounter$fShowTimingStats$fTimingDataInt$fTimingDataDouble$fBinaryTimingStats$fNFDataTimingStats$fShowSamplingStats$fSamplingDataInt$fSamplingDataDouble$fMonoidSamplingStats$fBinarySamplingStats$fNFDataSamplingStats$fConvertableToDoubleInt$fConvertableToDoubleDouble$fEqSamplingStats$fOrdSamplingStats$fGenericSamplingStats$fEqTimingStats$fOrdTimingStats$fGenericTimingStats$fEqSamplingCounter$fOrdSamplingCounter$fShowSamplingCounter$fGenericSamplingCounter$fEqTimingCounter$fOrdTimingCounter$fShowTimingCounter$fGenericTimingCounter PriorityQueue queueNull queueCount emptyQueueenqueuedequeue queueFront$fShowPriorityQueuenewQueue queueDelete queueDeleteBy queueContainsqueueContainsByremoveremoveBy GeneratorTypeSimpleGeneratorSimpleGeneratorWithSeedCustomGeneratorCustomGenerator01 GeneratorgenerateUniformgenerateUniformIntgenerateTriangulargenerateNormalgenerateLogNormalgenerateExponentialgenerateErlanggeneratePoissongenerateBinomial generateGamma generateBetagenerateWeibullgenerateDiscretegenerateSequenceNo DiscretePDF newGeneratornewRandomGeneratornewRandomGenerator01 EventQueuequeuePQ queueBusy queueTimePoint pointSpecspointRun pointTimepointIteration pointPhaseRunrunSpecsrunIndexrunCount runEventQueue runGeneratorMethodEuler RungeKutta2 RungeKutta4Specs spcStartTime spcStopTimespcDT spcMethodspcGeneratorType newEventQueueintegIterationBndsintegIterationLoBndintegIterationHiBndintegPhaseBndsintegPhaseLoBndintegPhaseHiBnd basicTime integTimes integPointsintegStartPointintegStopPointpointAtintegPointsStartingFrom $fEqMethod $fOrdMethod $fShowMethod ParameterLift liftParameter Parameter runParameter runParameterssimulationIndexsimulationCountsimulationSpecsgeneratorParametercatchParameterfinallyParameterthrowParameterinvokeParameter memoParametertableParameter starttimestoptimedt$fMonadFixParameter$fParameterLiftParameter$fMonadIOParameter$fFloatingParameter$fFractionalParameter$fNumParameter$fShowParameter $fEqParameter$fApplicativeParameter$fFunctorParameter$fMonadParameterSimulationRetrySimulationAbortSimulationExceptionSimulationLiftliftSimulation Simulation runSimulationrunSimulationByIndexrunSimulationssimulationEventQueuecatchSimulationfinallySimulationthrowSimulationinvokeSimulationmemoSimulation$fExceptionSimulationRetry$fExceptionSimulationAbort$fExceptionSimulationException$fShowSimulationException$fMonadFixSimulation$fParameterLiftSimulation$fSimulationLiftSimulation$fMonadIOSimulation$fApplicativeSimulation$fFunctorSimulation$fMonadSimulation$fShowSimulationAbort$fShowSimulationRetry DynamicsLift liftDynamicsDynamicsrunDynamicsInStartTimerunDynamicsInStopTimerunDynamicsInIntegTimesrunDynamicsInTimerunDynamicsInTimes catchDynamicsfinallyDynamics throwDynamicsinvokeDynamicstime isTimeIntegintegIteration integPhase traceDynamics$fMonadFixDynamics$fDynamicsLiftDynamics$fSimulationLiftDynamics$fParameterLiftDynamics$fMonadIODynamics$fFloatingDynamics$fFractionalDynamics $fNumDynamics$fShowDynamics $fEqDynamics$fApplicativeDynamics$fFunctorDynamics$fMonadDynamicsDisposableEvent disposeEventEventCancellation cancelEventeventCancelled eventFinishedEventProcessing CurrentEvents EarlierEventsCurrentEventsOrFromPastEarlierEventsOrFromPast EventLift liftEventEvent catchEvent finallyEvent throwEvent invokeEvent enqueueEventrunEvent runEventWithrunEventInStartTimerunEventInStopTimeeventQueueCountenqueueEventWithTimesenqueueEventWithPointsenqueueEventWithIntegTimesenqueueEventWithStartTimeenqueueEventWithStopTimeenqueueEventWithCancellation memoEventmemoEventInTime yieldEvent retryEvent traceEvent$fMonoidDisposableEvent$fMonadFixEvent$fEventLiftEvent$fDynamicsLiftEvent$fSimulationLiftEvent$fParameterLiftEvent$fMonadIOEvent$fApplicativeEvent$fFunctorEvent $fMonadEvent$fEqEventProcessing$fOrdEventProcessing$fShowEventProcessingRefnewRefreadRefwriteRef modifyRefArrival arrivalValue arrivalTime arrivalDelay $fEqArrival $fOrdArrival $fShowArrival initDynamicsdiscreteDynamicsinterpolateDynamics scan1Dynamics scanDynamics memoDynamics memo0DynamicsiterateDynamics unzipDynamicsunzip0DynamicsmemoRandomUniformDynamicsmemoRandomUniformIntDynamicsmemoRandomTriangularDynamicsmemoRandomNormalDynamicsmemoRandomLogNormalDynamicsmemoRandomExponentialDynamicsmemoRandomErlangDynamicsmemoRandomPoissonDynamicsmemoRandomBinomialDynamicsmemoRandomGammaDynamicsmemoRandomBetaDynamicsmemoRandomWeibullDynamicsmemoRandomDiscreteDynamics.==../=..<..>=..>..<=. maxDynamics minDynamics ifDynamicsinteg integEithersmoothIsmoothsmooth3Ismooth3smoothNIsmoothNdelay1Idelay1delay3Idelay3delayNIdelayNforecasttrenddiffsum diffsumEitherlookupDynamicslookupStepwiseDynamicsdelaydelayInpvnpvesteppulsepulsePramp randomUniformrandomUniformIntrandomTriangular randomNormalrandomLogNormalrandomExponential randomErlang randomPoissonrandomBinomial randomTrue randomFalse randomGamma randomBeta randomWeibullrandomDiscrete Transform runTransform timeTransformdelayTransformintegTransformintegTransformEither sumTransformsumTransformEither$fArrowTransform$fCategoryTYPETransform memoTransformmemo0TransformiteratingTransform initTransformdiscreteTransforminterpolatingTransformscan1Transform scanTransformDoubleLinkedListlistNull listCountnewListlistInsertFirst listAddLastlistRemoveFirstlistRemoveLast listFirstlistLast listRemove listRemoveBy listContainslistContainsBy clearList freezeListStaticPrioritiesSIROLCFSFCFSDeletingQueueStrategystrategyQueueDeletestrategyQueueDeleteBystrategyQueueContainsstrategyQueueContainsByPriorityQueueStrategystrategyEnqueueWithPriorityEnqueueStrategystrategyEnqueueDequeueStrategystrategyDequeue QueueStrategy StrategyQueuenewStrategyQueuestrategyQueueNull SIROQueueStaticPriorityQueue LCFSQueue FCFSQueue$fDeletingQueueStrategySIRO$fEnqueueStrategySIRO$fDequeueStrategySIROD:R:StrategyQueueSIROi0$fQueueStrategySIRO'$fDeletingQueueStrategyStaticPriorities-$fPriorityQueueStrategyStaticPrioritiesDouble!$fDequeueStrategyStaticPriorities#D:R:StrategyQueueStaticPrioritiesi0$fQueueStrategyStaticPriorities$fDeletingQueueStrategyLCFS$fEnqueueStrategyLCFS$fDequeueStrategyLCFSD:R:StrategyQueueLCFSi0$fQueueStrategyLCFS$fDeletingQueueStrategyFCFS$fEnqueueStrategyFCFS$fDequeueStrategyFCFSD:R:StrategyQueueFCFSi0$fQueueStrategyFCFS$fEqFCFS $fOrdFCFS $fShowFCFS$fEqLCFS $fOrdLCFS $fShowLCFS$fEqSIRO $fOrdSIRO $fShowSIRO$fEqStaticPriorities$fOrdStaticPriorities$fShowStaticPriorities CompositeLift liftComposite Composite runComposite runComposite_runCompositeInStartTime_runCompositeInStopTime_disposableComposite$fCompositeLiftComposite$fEventLiftComposite$fDynamicsLiftComposite$fSimulationLiftComposite$fParameterLiftComposite$fMonadFixComposite$fMonadIOComposite$fMonadComposite$fApplicativeComposite$fFunctorComposite SignalablereadSignalablesignalableChanged_ SignalHistorysignalHistorySignalSignal handleSignal SignalSource publishSignal triggerSignal handleSignal_handleSignalCompositenewSignalSource mapSignal filterSignal filterSignal_ filterSignalMfilterSignalM_ merge2Signals merge3Signals merge4Signals merge5Signals mapSignalMapSignal emptySignalnewSignalHistorynewSignalHistoryStartingWithreadSignalHistorynewSignalInTimesnewSignalInIntegTimesnewSignalInStartTimenewSignalInStopTimesignalableChangedemptySignalableappendSignalable arrivalSignal delaySignal delaySignalM traceSignal$fMonoidSignalable$fFunctorSignalable$fMonoidSignal$fFunctorSignal$fEqSignalHandler FrozenCont unfreezeCont ContParamsCont ContEventContCancellationInitiatingContPreemptionBeginningContPreemptionEndingContIdContCancellationCancelTogetherCancelChildAfterParentCancelParentAfterChildCancelInIsolation newContId contSignalcontCancellationInitiatingcontCancellationInitiatedcontCancellationActivatedcontCancellationBindcontCancellationConnectcontCancellationInitiatecontPreemptionBegincontPreemptionEndcontPreemptionBeginningcontPreemptionEndingcontPreemptionBegun invokeCont catchCont finallyCont throwContrunCont resumeCont resumeECont contCanceled contParallel contParallel_ rerunCont spawnCont freezeContfreezeContReentering reenterContsubstituteCont contAwait transferCont traceCont $fMonadIOCont$fApplicativeCont $fFunctorCont$fEventLiftCont$fDynamicsLiftCont$fSimulationLiftCont$fParameterLiftCont $fMonadCont $fEqContId $fEqContEvent$fOrdContEvent$fShowContEvent ProcessLift liftProcessProcess ProcessId invokeProcess holdProcessinterruptProcessprocessInterruptedprocessInterruptionTimepassivateProcesspassivateProcessBeforeprocessPassivereactivateProcessreactivateProcessImmediately runProcessrunProcessUsingIdrunProcessInStartTimerunProcessInStartTimeUsingIdrunProcessInStopTimerunProcessInStopTimeUsingIdenqueueProcessenqueueProcessUsingId processId newProcessIdcancelProcessWithId cancelProcessprocessCancelledprocessCancellingwhenCancellingProcessprocessPreemptionBeginprocessPreemptionEndprocessPreemptionBeginningprocessPreemptionEnding catchProcessfinallyProcess throwProcessprocessParallelprocessParallelUsingIdsprocessParallel_processParallelUsingIds_processUsingId spawnProcessspawnProcessUsingIdspawnProcessWithspawnProcessUsingIdWith processAwait memoProcesszipProcessParallelzip3ProcessParallel unzipProcesstimeoutProcesstimeoutProcessUsingId processYield neverProcess retryProcesstransferProcess traceProcess$fMonadIOProcess$fEventLiftProcess$fDynamicsLiftProcess$fSimulationLiftProcess$fParameterLiftProcess$fApplicativeProcess$fFunctorProcess$fMonadProcess $fEqProcessId$fProcessLiftProcessrandomUniformProcessrandomUniformProcess_randomUniformIntProcessrandomUniformIntProcess_randomTriangularProcessrandomTriangularProcess_randomNormalProcessrandomNormalProcess_randomLogNormalProcessrandomLogNormalProcess_randomExponentialProcessrandomExponentialProcess_randomErlangProcessrandomErlangProcess_randomPoissonProcessrandomPoissonProcess_randomBinomialProcessrandomBinomialProcess_randomGammaProcessrandomGammaProcess_randomBetaProcessrandomBetaProcess_randomWeibullProcessrandomWeibullProcess_randomDiscreteProcessrandomDiscreteProcess_ResourceresourceStrategyresourceMaxCountPriorityResource SIROResource LCFSResource FCFSResourcenewFCFSResourcenewFCFSResourceWithMaxCountnewLCFSResourcenewLCFSResourceWithMaxCountnewSIROResourcenewSIROResourceWithMaxCountnewPriorityResourcenewPriorityResourceWithMaxCount newResourcenewResourceWithMaxCount resourceCountrequestResourcerequestResourceWithPriorityreleaseResourcereleaseResourceWithinEventtryRequestResourceWithinEvent usingResourceusingResourceWithPriorityincResourceCountdecResourceCount $fEqResourceQueue queueMaxCountenqueueStrategyenqueueStoringStrategydequeueStrategy newFCFSQueue newLCFSQueue newSIROQueuenewPriorityQueue queueFulldequeueWithOutputPriority tryDequeue queueDelete_queueDeleteBy_ clearQueueenqueueWithInputPriorityenqueueWithStoringPriority!enqueueWithInputStoringPriorities tryEnqueuetryEnqueueWithStoringPriorityalterResourceCount$fEqResourceActingItemqueueNullChangedqueueNullChanged_queueFullChangedqueueFullChanged_queueCountStatsqueueCountChangedqueueCountChanged_ enqueueCountenqueueCountChangedenqueueCountChanged_enqueueLostCountenqueueLostCountChangedenqueueLostCountChanged_enqueueStoreCountenqueueStoreCountChangedenqueueStoreCountChanged_ dequeueCountdequeueCountChangeddequeueCountChanged_dequeueExtractCountdequeueExtractCountChangeddequeueExtractCountChanged_queueLoadFactorqueueLoadFactorChangedqueueLoadFactorChanged_ enqueueRateenqueueStoreRate dequeueRatedequeueExtractRate queueWaitTimequeueWaitTimeChangedqueueWaitTimeChanged_queueTotalWaitTimequeueTotalWaitTimeChangedqueueTotalWaitTimeChanged_enqueueWaitTimeenqueueWaitTimeChangedenqueueWaitTimeChanged_dequeueWaitTimedequeueWaitTimeChangeddequeueWaitTimeChanged_ queueRatequeueRateChangedqueueRateChanged_ enqueueOrLost enqueueWithStoringPriorityOrLostenqueueOrLost_!enqueueWithStoringPriorityOrLost_enqueueInitiated enqueueStored enqueueLostdequeueRequesteddequeueExtractedwaitWhileFullQueue queueChanged_ queueSummary resetQueue refChanged refChanged_GatenewGate newGateOpened newGateClosedopenGate closeGate invertGate gateOpened gateClosedawaitGateOpenedawaitGateClosed gateChanged_resourceCountStatsresourceCountChangedresourceCountChanged_resourceUtilisationCountresourceUtilisationCountStatsresourceUtilisationCountChanged resourceUtilisationCountChanged_resourceQueueCountresourceQueueCountStatsresourceQueueCountChangedresourceQueueCountChanged_resourceTotalWaitTimeresourceWaitTimeresourceWaitTimeChangedresourceWaitTimeChanged_resourceChanged_ resetResourceTimingStatsAccumulatortimingStatsAccumulatednewTimingStatsAccumulator TaskResult TaskCompleted TaskError TaskCancelledTasktaskIdtaskResultReceivedtryGetTaskResult taskResult cancelTask taskCancelledrunTaskUsingIdrunTaskenqueueTaskUsingId enqueueTaskspawnTaskUsingId spawnTaskspawnTaskUsingIdWith spawnTaskWith taskProcesstaskParallelResulttaskParallelProcessVarnewVarvarMemoreadVarwriteVar modifyVar freezeVar varChanged varChanged_StreamCons runStream streamUsingId memoStream zipStreamSeqzipStreamParallel zip3StreamSeqzip3StreamParallel unzipStream streamSeqstreamParallel repeatProcess mapStream mapStreamM accumStreamapStream apStreamM filterStream filterStreamM leftStream rightStreamreplaceLeftStreamreplaceRightStreampartitionEitherStream splitStreamsplitStreamQueueingsplitStreamPrioritisingsplitStreamFilteringsplitStreamFilteringQueueing concatStreamsconcatQueuedStreamsconcatPriorityStreams mergeStreamsmergeQueuedStreamsmergePriorityStreams emptyStream consumeStream sinkStreamprefetchStreamqueuedSignalStream signalStream streamSignal arrivalStream delayStreamsingletonStream joinStreamfailoverStream takeStreamtakeStreamWhiletakeStreamWhileM dropStreamdropStreamWhiledropStreamWhileM cloneStreamfirstArrivalStreamlastArrivalStreamassembleAccumStream traceStream$fMonoidStream$fAlternativeStream$fApplicativeStream$fFunctorStreamChannel runChannel delayChannel delayChannelM sinkSignal traceChannel$fCategoryTYPEChannel Processor runProcessoremptyProcessor arrProcessoraccumProcessorwithinProcessorprocessorUsingIdprocessorQueuedParallel#processorPrioritisingOutputParallel"processorPrioritisingInputParallel(processorPrioritisingInputOutputParallelprocessorParallel processorSeqbufferProcessorbufferProcessorLoopqueueProcessorqueueProcessorLoopMergingqueueProcessorLoopSeqqueueProcessorLoopParallelprefetchProcessorchannelProcessorprocessorChannelqueuedChannelProcessorqueuedProcessorChannelarrivalProcessordelayProcessor joinProcessorfailoverProcessortraceProcessor$fArrowPlusProcessor$fArrowZeroProcessor$fArrowChoiceProcessor$fArrowProcessor$fCategoryTYPEProcessorCircuit runCircuitcircuitSignalingcircuitProcessor arrCircuit accumCircuitarrivalCircuit delayCircuit timeCircuit>?>>><<<iterateCircuitInPoints_iterateCircuitInPointsiterateCircuitInPointsMaybeiterateCircuitInPointsEitherserverStateRef serverProcessserverProcessPreemptibleserverTotalInputWaitTimeRefserverTotalProcessingTimeRefserverTotalOutputWaitTimeRefserverTotalPreemptionTimeRefserverInputWaitTimeRefserverProcessingTimeRefserverOutputWaitTimeRefserverPreemptionTimeRefserverInputReceivedSource#serverTaskPreemptionBeginningSource serverTaskPreemptionEndingSourceserverTaskProcessedSourceserverOutputProvidedSourceserverProcessPreemptingarrivalProcessingTimeRef"arrivalProcessingTimeChangedSourcetriggerAgentStateChanged AgentMode CreationMode TransientModeProcessingModestateActivateRefstateDeactivateRefstateTransitRefstateVersionRef agentModeRef agentStateRefagentStateChangedSourcefullPath partitionPathfindPath traversePathactivityStateRefactivityProcessactivityProcessPreemptibleactivityTotalUtilisationTimeRefactivityTotalIdleTimeRefactivityTotalPreemptionTimeRefactivityUtilisationTimeRefactivityIdleTimeRefactivityPreemptionTimeRefactivityUtilisingSourceactivityUtilisedSource!activityPreemptionBeginningSourceactivityPreemptionEndingSourceactivityProcessPreemptingoperationInitProcessoperationProcessPreemptibleoperationStartTimeRefoperationLastTimeRef operationTotalUtilisationTimeRefoperationTotalPreemptionTimeRefoperationUtilisationTimeRefoperationPreemptionTimeRefoperationUtilisingSourceoperationUtilisedSource"operationPreemptionBeginningSourceoperationPreemptionEndingSourceoperationProcessPreempting apResultValuenormTimingStatsDataflattenResultSourceresultSourceNameexpandResultSourceresultSourceSummaryresultSourceSignal concatResults appendResultssamplingStatsResultSourcesamplingStatsResultSummarytimingStatsResultSourcetimingStatsResultSummarysamplingCounterResultSourcesamplingCounterResultSummarytimingCounterResultSourcetimingCounterResultSummaryqueueResultSourcequeueResultSummaryinfiniteQueueResultSourceinfiniteQueueResultSummaryarrivalTimerResultSourcearrivalTimerResultSummaryserverResultSourceserverResultSummaryactivityResultSourceactivityResultSummaryresourceResultSourceresourceResultSummarypreemptibleResourceResultSource preemptibleResourceResultSummaryoperationResultSourceoperationResultSummary intSubscript"hPrintResultSourceIndentedLabelled showResultSourceIndentedLabelled