Learning and Cognitive Systems

Simple Reaction Times (SRTs)

The purpose of this section is threefold. First, we want to model human response or reaction times within Card, Moran, and Newell's engineering framework The Model Human Processor (MHP). Here we start with Example 9. Second, we want to explore the possibility of specifying gamma distributions on the basis of empirical constraints. Third, we want to explore the expressibility and usability of the pure functional probabilistic WebPPL language. Comments and improvement proposals are welcome. Please feel free to send me one !

Card, Moran & Newell's Example 9. A user sits before a computer display terminal. Whenever any symbol appears, he is to press the space bar. What is the time between signal and response? (Card, Moran & Newell, 1983, p.66)

Card, Moran & Newell (CMN) use their Model Human Processor (MHP) - a simplified engineering model of the human perceptual-cognitive-motor system - to calculate the total user response time (TRT). They assume that the user is "... in some state of attention to the display ...". TRT is the sum of τ(P), τ(C), and τ(M). These are the cycle times in msec of the hypothetical perceptual processor, the cognitive processor, and the motor processor, respectively (CMN, Fig 2.1, p.26, p.66, p.433f)..

The uncertainties in the parameters of the MHP are captured by three versions of the MHP (CMN, 1983, p.44)

  • Middleman is the version ... in which all the parameters ... are set to give the normal perfomance.
  • Fastman is the version ... in which all the parameters ... are set to give the best perfomance.
  • Slowman is the version ... in which all the parameters ... are set to give the worst perfomance.

Cycle times are reported by CMN according notation templates

τ(X) ≡ μ(X) [fast(X) ~ slow(X)]

TRT TRT(Middleman)  [TRT(Fastman) ~ TRT(Slowman)]

The meaning of this notation is that τ(X) or the total reaction time (TRT) is ranging from low(X) to high(X) with mean value μ(X)

Empirical tau-intervals are:

  • τ(P) ≡ 100 [50 ~ 200] msec ; cycle time of perceptual processor
  • τ(C) ≡ 70 [25 ~ 170] msec ; cycle time of cognitive processor
  • τ(M) ≡ 70 [30 ~ 100] msec ; cycle time of motor processor
  • TRTτ = τ(P) + τ(C) + τ(M) ≡ 240 [105 ~ 470].

We treat τ and the variables τ(X) as gamma distributed random variables. Gamma distributions seem to be useful in modeling response or reaction times (van Zandt, 2000).

Specification of the Generative Probabilistic SRT Model by Empirical Constraints

We try to model τ(X) are gamma distributed random variables. Their sum represents the random variable τ (= TRT). The distribution of a sum of independent gamma random variables is treated in Mathai (1982) and Moschopoulos (1985). Instead we derive the distribution of τ by sampling from a generative probabilistic model.

There are three parametrizations of the gamma distribution. We choose that one with shape parameter k and scale parameter θ (with k, θ > 0). Mean, variance, and standard deviations of a gamma-distributed random variable X are functions of these parameters: \(E(X) = k\theta\), \(Var(X) = k\theta^2\), and \(\sqrt {Var(X)} = \sigma(X) = \sqrt {k}\theta\ \).

In the computer programs we use the substitutions "k/a" ("a for k") and θ/b ("b for θ"). 

To specify the gamma parameters we map the concepts of the empirical intervals

$$\tau(X)=\mu(X)\,\,[fast(X) \sim slow(X)]$$

to the moments of the gamma distribution (the identifiers m, s, r are shorthands in computer code):

$$\mu(X) = ab \equiv m$$

$$\sigma(X) = \sqrt{a}b \equiv s$$

$$fast(X) = (ab - 2r\sqrt{a}b) \equiv (m-2rs)$$

and

$$slow(X) = (ab + 2r\sqrt{a}b) \equiv  m+2rs$$

So the length of an -interval (r = 1,2,3,...) is

$$(slow(X)-fast(X)) = 2r\sqrt{a}b \equiv 2rs$$

The semantics of the CMN-distribution could be now given by the moments of a gamma distribution:

$$\tau(X)=\mu(X)\,\,[fast(X) \sim slow(X)] = ab\,\,[ab-r\sqrt{a}b \sim ab+r\sqrt{a}b] \equiv m\,[m-2rs \sim m+2rs]$$

Now, we have to identify the parameters or a and b. Solving towards a and b we get:

$$a=\frac{ab}{b}=\frac{m}{b}$$

$$b=\frac{(slow(X)-fast(X))}{2r \sqrt{a}}$$

 We substitute \(a = \frac{m}{b}\) into the formula for b:

$$b=\frac{(slow(X)-fast(X))}{2r \sqrt{\frac{m}{b}}}$$

square both sides:

$$b^2=\frac{(slow(X)-fast(X))^2}{2^2r^2 \left(\frac{m}{b}\right)}=\frac{(slow(X)-fast(X))^2}{2^2r^2}\frac{b}{m}$$

Cancelling b on both sides:

$$b=\frac{(slow(X)-fast(X))^2}{2^2r^2 m}$$

Now, b is totally identified by the estimators or empirical constraints slow(X), mean(X) = m, and fast(X). This is not the case for a. So we substitute b back into the equation for a. This gives:

$$a=\frac{m}{b}=m*\frac{2^2r^2m}{(slow(X)-fast(X))^2}=\frac{(2rm)^2}{(slow(X)-fast(X))^2}$$

We check the results:

$$ab=\frac{(2rm)^2}{(slow(X)-fast(X))^2} * \frac{(slow(X)-fast(X))^2}{(2r)^2 m}=\frac{2^2r^2m^2}{2^2r^2m}=m$$

WebPPL-Code of Probabilistic SRT Model

console.log("==============================================================================")
console.log("file: PCM20180223_SimpleReactionTime     *** version 2018/03/25 *** by PCM ***")
console.log("Simple Reaction Time, Example 9, Card, Moran & Newell, 1983, p.66             ")
console.log("==============================================================================")
/**
 * @author Claus Moebus <claus.moebus@uol.de>
 */
/**
 * @variable {number} startTime - used in method 'runtime' to compute runtime in sec and min
 */
var startTime = Date.now() 
//------------------------------------------------------------------------------------------
/**
 * @variable {integer} nTrials - #samples taken from various probability distributions
 */
var nTrials = 25E3
console.log("nTrials = ", nTrials)
//------------------------------------------------------------------------------------------
/**
 * @variable {integer} nSigma - number of standard deviations measuring the
 *                              distance between interval boundaries and mean:
 *                              |fast - mean| = |slow - mean| = nSigma*sigma
 */
var nSigma = 3 // fast = mean - nSigma*sigma, slow = mean + nSigma*sigma
console.log("nSigma = ", nSigma)
//------------------------------------------------------------------------------------------
/**  
 * @variable {integer} nSigmaInterval - number standard deviations for the distance between
 *                                      lower and higher interval boundary:
 *                                      |fast - slow| = nSigmaInterval*sigma
 */
var nSigmaInterval = nSigma*2
console.log("nSigmaInterval (= interval width in sigmas) = ", nSigmaInterval)
var nSigmaIntervalSq = Math.pow(nSigmaInterval, 2)
console.log("==============================================================================")
//------------------------------------------------------------------------------------------
// method and function definitions (part I)
//------------------------------------------------------------------------------------------
/**
 * @function runtime - method to compute the runtime in seconds and minutes
 */
var runTime = function() {
  var stopTime = Date.now()
  var runSecs = (stopTime - startTime)/1000
  var runMins = runSecs/60
  console.log("runtime in seconds = ", runSecs)
  console.log("runtime in minutes = ", runMins)}
//------------------------------------------------------------------------------------------
/**
 * @function printArrayOfObjects - prints an identifier and an array of objects
 * @param {string} string - The identifier of the array.
 * @param {array} arrayOfObjects - The array of objects.
 */
var printArrayOfObjects = function(string, arrayOfObjects) {
  console.log(string)
  /**
   * @function repeat - generates a comma separated array [-,-, ... ,-] with length |string|
   * @param {integer} string.length - length of string = |string|
   * @param {thunk} function(){'-'} - thunk generates one '-'
   * @returns {array} - comma separated array [-,-, ... ,-] with length |string|          
   */
  /**
   * @function array.toString() - converts an array to a string
   * @param {array} [-,-, ... ,-]
   * @returns {string} "-,-, ... ,-"                                                      
   */
  /**
   * @function string.replace(/,/g,'') - deletes all ',' in string
   * @param {character} /,/g - what should be replaced
   * @param {character} '' - what should be inserted
   * @returns {string} "-- ... -"                                                         
   */
  var myLine = repeat(string.length, function(){'-'}).toString().replace(/,/g,'')
  console.log(myLine)
  map(function(object){print(object)}, arrayOfObjects)}
//------------------------------------------------------------------------------------------
/**
 * @function make_tauX_Intvals - constructs an array of interval objects
 * @property {string} id - 'tauP', 'tauC', 'tauM', 'tauT' (cognitive processor cycle)
 * @property {number} fast - lower boundary of response time (RT) interval (fastest RT)
 * @property {number} mean - expectation of response time (RT) interval (fastest RT)
 * @property {number} slow - higher boundary of response time (RT) interval (slowest RT)
 * @property {number} scaleFactor - factor to stretch or compress scale of distribution
 * @returns {array of objects} tauX_Intervals where X = P, C, M, T
 */
var make_tauX_Intvals = function() {
  var tauP_Intval = {id: "tauP", fast: 50, mean:100, middle:(50+200)/2, slow:200,
                     scaleFactor: 1.00} // 0.445}
  var tauC_Intval = {id: "tauC", fast: 25, mean: 70, middle:(25+170)/2, slow:170,
                     scaleFactor: 1.00} // 0.39}
  var tauM_Intval = {id: "tauM", fast: 30, mean: 70, middle:(30+100)/2, slow:100,
                     scaleFactor: 1.00} // 1.3}
  var tauT_Intval = {id: "tauT", fast:105, mean:240, middle:(105+470)/2, slow:470,
                     scaleFactor: 1.00} // ??? }
  var tauX_Intervals = [tauP_Intval, tauC_Intval, tauM_Intval, tauT_Intval]
  printArrayOfObjects("tauX_Intervals: ", tauX_Intervals)
  return tauX_Intervals}
//------------------------------------------------------------------------------------------
/**
 * @description - computes shape, scale, and mode from empirical params mean, low, and high
 * @function make_tauXParmObject - computes parameter object from data interval object
 * @param {object} tauX_Intval - object with properties id, low, mean, high, scaleFactor
 * @property {string} id - identifier tauX where X = P, C, M, T
 * @property {number} fast - lower boundary of response time (RT) interval (fastest RT)
 * @property {number} mean - empirical expectation of RT interval (mean RT)
 * @property {number} slow - higher boundary of response time (RT) interval (slowest RT)
 * @property {number} scaleFactor - factor to stretch or compress scale of distribution
 * @returns {object} tauXParmObject with properties id, a, b, mode, mean, oneSigma,
 *                                  nSigmaDistance where X = P, C, M, T
 * @property {number} a - shape parameter of gamma distribution
 * @property {number} b - scale parameter of gamma distribution
 * @property {number} mode - mode, a derived parameter of gamma distribution
 * @property {number} mean - mean, a derived parameter of gamma distribution
 * @property {number} oneSigma - standard deviation sigma, a derived parameter
 * @property {number} nSigmaDistance - distance RT-boundary from mean
 */
var make_tauXParmObject = function(tauX_Intval) {
  /** shape parameter a and scale parameter b    */
  var make_a = function(fast, mean, slow) {
    (nSigmaIntervalSq * Math.pow(mean, 2)) / Math.pow((slow - fast), 2)}
  var make_b = function(fast, mean, slow) {
    Math.pow((slow-fast), 2) / (nSigmaIntervalSq * mean)}
  var a = make_a(tauX_Intval.fast, tauX_Intval.mean, tauX_Intval.slow) /
      tauX_Intval.scaleFactor
  var b = make_b(tauX_Intval.fast, tauX_Intval.mean, tauX_Intval.slow) *
      tauX_Intval.scaleFactor
  /** mean, sigma, and mode                                                               
   */
  var mean = a * b
  var sigma = Math.sqrt(a) * b
  var mode = (a >= 1) ? (a - 1) * b : Null
  var tauXParmObject = 
      {id:tauX_Intval.id, a:a, b:b, mode: mode, mean:mean, oneSigma: sigma,
       nSigmaDistance: nSigma*sigma}
  return tauXParmObject}
//------------------------------------------------------------------------------------------
// initialize data and parameter objects
//------------------------------------------------------------------------------------------
/**
 * @variable {array} tauX_Intvals - an array of interval objects
 */
var tauX_Intvals = make_tauX_Intvals()
console.log("==============================================================================")
//------------------------------------------------------------------------------------------
/** computes array of parameter objects with gamma parameters from empirical interval objects

 * @variable {array} tauXParmObjects - an array of gamma parameter objects with properties
 * @property {number} a - shape
 * @property {number} b - scale
 * @property {number} mode - (a-1)*b if a >= 1
 * @property {number} mean - a*b
 * @property {number} sigma - sqrt(a)*b
 */
var tauXParmObjects = map(make_tauXParmObject, tauX_Intvals)
printArrayOfObjects("tauXParmObjects:", tauXParmObjects)
console.log("==============================================================================")
//------------------------------------------------------------------------------------------
// function definitions (part II)
//------------------------------------------------------------------------------------------
/**
 * @description - takes one sample by sampling gamma-distributed tauX (X = P, C, M, T)
 *                and adding these to tau = tauP + tauC + tauM
 * @function takeOneSampleOfGammaModel
 * @name {number} tauP_a - shape parameter taken from tauXParmObjects[0].a
 * @name {number} tauP_b - scale parameter taken from tauXParmObjects[0].b
 * @name {number} tauC_a - shape parameter taken from tauXParmObjects[1].a
 * @name {number} tauC_b - scale parameter taken from tauXParmObjects[1].b
 * @name {number} tauM_a - shape parameter taken from tauXParmObjects[2].a
 * @name {number} tauM_b - scale parameter taken from tauXParmObjects[2].b
 * @name {number} tauT_a - shape parameter taken from tauXParmObjects[3].a
 * @name {number} tauT_b - scale parameter taken from tauXParmObjects[3].b
 * @returns {object} tauObject with properties tauP, tauC, tauM, tauT, tau
 * @property {number} tauP - sample(Gamma({shape:tauP_a, scale:tauP_b}))
 * @property {number} tauC - sample(Gamma({shape:tauC_a, scale:tauC_b}))
 * @property {number} tauM - sample(Gamma({shape:tauM_a, scale:tauM_b}))
 * @property {number} tauT - sample(Gamma({shape:tauT_a, scale:tauT_b}))
 * @property {number} tau  - (tauP + tauC + tauM)
 */
var takeOneSampleOfGammaModel = function() {
  var tauP_a = tauXParmObjects[0].a; var tauP_b = tauXParmObjects[0].b
  var tauP = sample(Gamma({shape:tauP_a, scale:tauP_b})) //  long form
  var tauC_a = tauXParmObjects[1].a; var tauC_b = tauXParmObjects[1].b
  var tauC = sample(Gamma({shape:tauC_a, scale:tauC_b})) //  long form
  var tauM_a = tauXParmObjects[2].a; var tauM_b = tauXParmObjects[2].b
  var tauM = sample(Gamma({shape:tauM_a, scale:tauM_b})) //  long form
  var tauT_a = tauXParmObjects[3].a; var tauT_b = tauXParmObjects[3].b
  var tauT = sample(Gamma({shape:tauT_a, scale:tauT_b})) //  long form
  var tau  = (tauP + tauC + tauM)
  var tauObject = {tauP:tauP, tauC:tauC, tauM:tauM, tauT:tauT, tau:tau}
  return tauObject}                    
//--------------------------------------------------------------------
/**
 * @description - descriptive statistics of a sample-generated gamma distribution
 * @function myTauXDistribution
 * @param {string} id - The identifier of the tauX distribution.
 * @param {distributionObject} tauXDistribution - tauX distribution (X = P, C, M, T)
 * @param {number} modeTauX - mode of tauX as a function of a and b
 *                            mode = (a-1)*b for a >= 1
 * @returns {object} meanSigmaTauObject - object with mean and sigma of TauX
 * @property {number} meanTauX - mean of tauX (X = P, C, M, T) or tau
 * @property {number} sigmaTauX - standard deviation of tauX (X = P, C, M, T) or tau
 */
var myTauXDescription = function(id, tauXDistribution, modeTauX) {
  var myTauXDistribution = { // extraction of probs and support from WebPPL tauX distribution
    probs: map(function(eventTuple){ // object to compute mean and sigma of tauX
      Math.exp(tauXDistribution.score(eventTuple))}, tauXDistribution.support()),
    support: tauXDistribution.support()}
  console.log("----------------------------------------------------------------------------")
  console.log(id)
  // mode(tauX), mean(tauX), variance(tauX) and sigma(tauX)
  console.log("mode = ", modeTauX)
  var meanTauX = sum(map2(function(value, prob) {
    value*prob},myTauXDistribution.support, myTauXDistribution.probs))
  console.log("mean = ", meanTauX)
  var sigmaTauX = Math.sqrt(sum(map2(function(value, prob) {
    Math.pow((value-meanTauX), 2)*prob},
                                     myTauXDistribution.support,
                                     myTauXDistribution.probs)))
  console.log("sigma = ", sigmaTauX)
  var tauX_Intval = {fast:meanTauX - nSigma * sigmaTauX, mean:meanTauX,
                     slow:meanTauX + nSigma * sigmaTauX}
  console.log("model-generated nSigma*sigma tau-interval: "); print(tauX_Intval)
  var meanSigmaTauXObject = {meanTauX: meanTauX, sigmaTauX: sigmaTauX}
  return meanSigmaTauXObject}
//------------------------------------------------------------------------------------------
// START of function applications
//------------------------------------------------------------------------------------------
console.log("model-generated tauX (X = P, C, M) and tau (= tauP + tauC + tauM) variables:")
/**
 * @variable {object} tauMultivDistribution - multivariate gamma distribution object
 */
var tauMultivDistribution =
    Infer({model:takeOneSampleOfGammaModel, method:'forward', samples:nTrials})
viz.marginals(tauMultivDistribution)
/**
 * @variable {object} tauXDistribution - value is univariate gamma distribution object
 */
var tauPDistribution = marginalize(tauMultivDistribution,function(x){x.tauP})
var tauCDistribution = marginalize(tauMultivDistribution,function(x){x.tauC})
var tauMDistribution = marginalize(tauMultivDistribution,function(x){x.tauM})
var tauTDistribution = marginalize(tauMultivDistribution,function(x){x.tauT})
var  tauDistribution = marginalize(tauMultivDistribution,function(x){x.tau})
/**
 * @variable {object} descriptObjectTauX - value is {meanTauX: meanTauX, sigmaTauX: sigmaTauX}
 */
var descriptObjectTauP = myTauXDescription("tauP: ",tauPDistribution, tauXParmObjects[0].mode)
var descriptObjectTauC = myTauXDescription("tauC: ",tauCDistribution, tauXParmObjects[1].mode)
var descriptObjectTauM = myTauXDescription("tauM: ",tauMDistribution, tauXParmObjects[2].mode)
var descriptObjectTauT = myTauXDescription("tauT: ",tauTDistribution, tauXParmObjects[3].mode)
var descriptObjectTau = myTauXDescription("tau=tauP+tauC+tauM: ",tauDistribution, "unknown")
console.log("------------------------------------------------------------------------------")
/** fitted tau-gamma parameters are estimates derived from mean- and sigma-statistics of
 *         the simulated tau-gamma distribution contained in the tauDistribution object
 *         tau = (tauP + tauC + tauM)
 * @variable {number} fitted_a - shape parameter a = (mean/sigma)^2
 * @variable {number} fitted_b - scale parameter b = (sigma^2)/mean 
 */
var fitted_a = Math.pow(descriptObjectTau.meanTauX / descriptObjectTau.sigmaTauX, 2)
var fitted_b = Math.pow(descriptObjectTau.sigmaTauX, 2) / descriptObjectTau.meanTauX
console.log("fitted_a = (mean/sigma)^2 = ", fitted_a)
console.log("fitted_b = (sigma^2)/mean = ", fitted_b)
/** mode of the fitted tau-gamma distribution is a function of its parameters a and b */
var fitted_mode = (fitted_a >= 1) ? (fitted_a - 1)*fitted_b : Null
console.log("fitted_mode = '('fitted_a - 1')'*fitted_b if fitted_a >= 1 = ", fitted_mode)
//------------------------------------------------------------------------------------------
/**
 * @description - sampling model function for inference of tau gamma distribution
 *                (tau = tauP + tauC + tauM)
 * @function takeOneSampleFittedTau
 * @returns {number} tau - one gamma distributed sample
 */
var takeOneSampleFittedTau = function() {
  var tau = sample(Gamma({shape:fitted_a, scale:fitted_b})) //  long form
  return tau} 
/**
 * @variable {distributionObject} tauFittedDistribution - value is a distribution object  
 */
var tauFittedDistribution =
    Infer({model:takeOneSampleFittedTau, method:'forward', samples:nTrials})
console.log("------------------------------------------------------------------------------")
console.log("fitted TRT-variable tau: ")
viz.density(tauFittedDistribution, {xLabel:"fitted TRT-variable tau"})
/**
 * @variable {object} descriptObjectFittedTau - object with mean and sigma of fittedTau
 */
var descriptObjectFittedTau =
    myTauXDescription("fitted tau: ", tauFittedDistribution, fitted_mode)
//------------------------------------------------------------------------------------------
runTime()
console.log("==============================================================================")


Simulation Results of Probabilistic SRT Model

==============================================================================

file: PCM20180223_SimpleReactionTime     *** version 2018/03/25 *** by PCM ***

Simple Reaction Time, Example 9, Card, Moran & Newell, 1983, p.66             

==============================================================================

nTrials =  25000

nSigma =  3

nSigmaInterval (= interval width in sigmas) =  6

==============================================================================

tauX_Intervals: 

----------------

{"id":"tauP","fast":50,"mean":100,"middle":125,"slow":200,"scaleFactor":1}

{"id":"tauC","fast":25,"mean":70,"middle":97.5,"slow":170,"scaleFactor":1}

{"id":"tauM","fast":30,"mean":70,"middle":65,"slow":100,"scaleFactor":1}

{"id":"tauT","fast":105,"mean":240,"middle":287.5,"slow":470,"scaleFactor":1}

==============================================================================

tauXParmObjects:

----------------

{"id":"tauP","a":16,"b":6.25,"mode":93.75,"mean":100,"oneSigma":25,"nSigmaDistance":75}

{"id":"tauC","a":8.39001189060642,"b":8.343253968253968,"mode":61.656746031746025,"mean":70,"oneSigma":24.166666666666668,"nSigmaDistance":72.5}

{"id":"tauM","a":36,"b":1.9444444444444444,"mode":68.05555555555556,"mean":70,"oneSigma":11.666666666666666,"nSigmaDistance":35}

{"id":"tauT","a":15.564646275098518,"b":15.419560185185185,"mode":224.5804398148148,"mean":240,"oneSigma":60.833333333333336,"nSigmaDistance":182.5}

==============================================================================

model-generated tauX (X = P, C, M) and tau (= tauP + tauC + tauM) variables:

 

tauP:

-------------------------

Fig01_tauP (see below)

-------------------------

 

tauC:

-------------------------

Fig02_tauC (see below)

-------------------------

 

tauM:

-------------------------

Fig03_tauM (see below)

-------------------------

 

tauT:

-------------------------

Fig04_tauT (see below)

-------------------------

 

tau:

-------------------------

Fig05_tau  (see below)

-------------------------

----------------------------------------------------------------------------

tauP: 

mode =  93.75

mean =  100.11529107858573

sigma =  25.048632877001545

model-generated nSigma*sigma tau-interval: 

{"fast":24.9693924475811,"mean":100.11529107858573,"slow":175.26118970959035}

----------------------------------------------------------------------------

tauC: 

mode =  61.656746031746025

mean =  70.03736175866905

sigma =  24.141177787856208

model-generated nSigma*sigma tau-interval: 

{"fast":-2.386171604899573,"mean":70.03736175866905,"slow":142.46089512223767}

----------------------------------------------------------------------------

tauM: 

mode =  68.05555555555556

mean =  70.0483235570372

sigma =  11.741623226274797

model-generated nSigma*sigma tau-interval: 

{"fast":34.8234538782128,"mean":70.0483235570372,"slow":105.27319323586158}

----------------------------------------------------------------------------

tauT: 

mode =  224.5804398148148

mean =  240.49399814850108

sigma =  60.646612408918365

model-generated nSigma*sigma tau-interval: 

{"fast":58.55416092174599,"mean":240.49399814850108,"slow":422.4338353752562}

----------------------------------------------------------------------------

tau=tauP+tauC+tauM: 

mode =  unknown

mean =  240.20097639429335

sigma =  36.896609813728055

model-generated nSigma*sigma tau-interval: 

{"fast":129.51114695310918,"mean":240.20097639429335,"slow":350.8908058354775}

------------------------------------------------------------------------------

fitted_a = (mean/sigma)^2 =  42.381527935092116

fitted_b = (sigma^2)/mean =  5.667586519347872

fitted_mode = '('fitted_a - 1')'*fitted_b if fitted_a >= 1 =  234.53338987494547

------------------------------------------------------------------------------

 

fitted TRT-variable tau: 

-----------------------------

Fig06_fittedTau (see below)

-----------------------------

----------------------------------------------------------------------------

fitted tau: 

mode =  234.53338987494547

mean =  240.28896372037406

sigma =  36.845873172002584

model-generated nSigma*sigma tau-interval: 

{"fast":129.75134420436632,"mean":240.28896372037406,"slow":350.8265832363818}

runtime in seconds =  527.431

runtime in minutes =  8.790516666666667

==============================================================================