30:T580,# Playing the Waiting Game ## The Inspection Paradox in Renewal Processes *Eric Chen* The goal of this notebook is to provide an introduction to renewal theory, and in particular: explain, derive, and simulate the so-called *inspection paradox*. All you'll need is some basic probability (at the intro undergraduate level, with calculus).

# Introduction Waiting sucks. Any type of waiting is generally unpleasant. Who's gonna disagree? Well, bad news for us. Under a reasonable model for waiting times, you — yes, you specifically — will almost surely wait *longer* on average than the average wait time itself. Wait... how is this true? Shouldn't your average wait time be exactly that: the average wait time? Are we just unlucky? Should we reject probability? As is tradition in math, the result might be unintuitive, but the explanation is subtle and insightful. This phenomenon is called the **inspection paradox**, and it has something to do with the distinction between *your* average wait time and *the* true average wait time. It's also a pretty great excuse for being late. You can tell your boss that math said so! ... OK, fine, "all models are wrong" or whatever. But, don't disregard our claim just yet. Our "waiting paradox" is just one instance of a much deeper result in statistics. Let's get going — why wait any more?

31:Te43,# Background Actually, I'll make you wait for the actual, mathematical formulation of the inspection paradox. We'll need some background knowledge first! Let's build up some layers of abstraction; we'll proceed from the general to the specific. ## Point Processes At its most general, a **random point process** is a collection of randomly distributed points in some mathematical space, which we call the **index set**. This space could be anything from our friendly ${tex`n`}-dimensional Euclidean space to some weird, complex manifold. In this article, we'll restrict our scope to the non-negative real line ${tex`\mathbb{R}_{\geq 0}`}. We can think of this set as *time*, making our point process a *temporal point process*.

## Renewal Processes A **renewal process** is a random point process where the "spaces" between points are *independent and identically distributed*, or *i.i.d.* for short. When our index set is ${tex`\mathbb{R}_{\geq 0}`}, we can interpret the spaces between points as times between arrivals, or *renewals*. A renewal process is characterized by: * a **counting process** ${tex`N(t)`}, denoting the number of arrivals by time ${tex`t`} for ${tex`t \geq 0`} * an **interarrival process** ${tex`\{X_n\}_{n \in \mathbb{N}}`}, denoting the time in between consecutive arrivals for ${tex`{n \in \mathbb{N}}`}. Each ${tex`X_n`} is called an **interarrival time** or **holding time**. The interarrival times must be i.i.d., as this is what characterizes a renewal process. The interarrival process can itself be characterized by the following quantities: * ${tex`F`} is the cumulative distribution function (CDF) of the **interarrival distribution** * ${tex`\lambda = \frac1{\mathrm{E}[X]}`} is the **rate** of the interarrival process, where we have ${tex`\{X_n\}_{n\in\mathbb{N}} \stackrel{\mathrm{\tiny{i.i.d.}}}{\sim} F`}. ^{It only makes sense to have *positive* interarrival times! Thus, ${tex`\mathrm{E}[X] > 0`} and ${tex`X \geq 0`} almost surely.}

## Poisson Processes If the interarrival distribution is an exponential distribution with mean ${tex`\lambda`}, then the renewal process is called a **Poisson process** with constant *rate* or *intensity* ${tex`\lambda`}. This is a special case, and the theory here is far richer than we'll cover in this write-up. They're often used in practical applications due to their many desirable properties: * the number of arrivals ${tex`N(t)`} is *Poisson-distributed* with mean ${tex`\lambda t`} * the interarrival times ${tex`\{X_n\}`} are *exponentially-distributed* with rate ${tex`\lambda`} * the Poisson process is the unique *memoryless* renewal process * the Poisson process is a special type of *continuous-time Markov chain* * the Poisson process possesses *independent and stationary increments* Take a look at "Poisson's Stroboscope" to get a feel for the process. It's not intuitive.

----

^{Technically, these are *homogeneous* Poisson processes. A *nonhomogeneous* or inhomogeneous Poisson process is a generalization in which the intensity need not be constant, and can be any integrable function of time. Strictly speaking, these are not renewal processes in the way we've defined above.}

32:T428,# The Inspection Paradox Suppose you arrive and start waiting at time ${tex`t`}, with ${tex`t`} *uniformly distributed* across the entire time horizon. In other words, you're equally likely to arrive at any given time. Let ${tex`A(t) = t_{N(t)+1}-t`} denote the amount of time until the next arrival; i.e., the waiting time. This quantity is known as the **forward recurrence time** or **excess**. Let ${tex`B(t) = t - t_{N(t)}`} represent the amount of time elapsed since the previous arrival. This quantity is referred to as the **backward recurrence time** or **age**. Finally, let ${tex`S(t) = A(t) + B(t)`} represent the total length of the interval you've happened to stumble into; i.e., the actual interarrival time. This is the **spread**. ## The Result The inspection paradox states that the average value of the spread is greater than the average interarrival time, or equivalently, the average value of the excess is greater than the average "wait time" (which is equal to half of the average interarrival time):33:Tab4,

^{In case you’re interested, we can actually prove the above results with the **renewal-reward theorem**.}

Note that ${tex`\frac{\mathrm{E}[X^2]}{\mathrm{E}[X]} \geq \,\mathrm{E}[X]`} since ${tex`\mathrm{E}[X^2] = \mathrm{Var}(X) + \mathrm{E}[X]^2`}, and the variance of any random variable must be non-negative. Therefore, we have ${tex`\mathrm{E}[X^2] \geq \mathrm{E}[X]^2`}, and dividing through by ${tex`\mathrm{E}[X]`} on both sides will give you the results we see above. If you arrive randomly within an average interval, your average wait time should simply be half of the average interarrival time: ${tex`\mathrm{E}[X] \,/\, 2`}. However, if you arrive randomly at any point in time, your average wait time — the average excess — will be greater: ${tex`\mathrm{E}[X^2] \,/\, 2\mathrm{E}[X]`}. This is a statement on the *expected values* of the wait times. We can actually make a stronger claim: the spread is **stochastically larger** than the interarrival distribution. Mathematically, we can write ${tex`P(S(t) > \ell) \geq P(X > \ell)`} for any fixed time ${tex`t`} and any interval length ${tex`\ell`}. This is a statement concerning not just their expected values, but the random variables and their *distributions* themselves. ## The Reason So, we've claimed that the inspection paradox is a mathematical truth, which you can verify! But that still leaves us yearning for some intuition; *why* does this happen? First, see that when you calculate the true average wait time, we are calculating the average across *intervals*. Each interval is equally weighted. When we calculate the average excess, we are calculating the average across *time*; the weighting is different. The paradox arises because you're more likely to arrive in a *non-average* interval. Specifically, you're more likely to arrive within a longer-than-average interval just by virtue of that interval being longer than average. To see this, suppose we repeated this "experiment" many times: *our* arrival time is uniformly distributed across the entire time horizon, so we'd tend to under-sample short intervals and over-sample long intervals. Therefore, our perceived average wait time is biased upwards from the true average wait time, which is taken across all such intervals, including the short ones that are unlikely to get "sampled". Essentially, there is a distinction between *your* average wait time and the *true* average wait time, and the difference is due to **sampling bias**. When we *inspect* or observe the process as such, counterintuitive things can occur.

34:T1565,description = { switch (mode) { case "log-normal": return md`The **log-normal distribution** is parameterized by a *log-mean* ${tex`\mu`} and a *log-variance* ${tex`\sigma^2 > 0`}. It's often used to model phenomena that are affected by many independent, multiplicative factors; to see this, consider the central limit theorem on a log-scale. Such phenomena range from the length of chess games to a user's screen time.

*analytical* mean interarrival: ${tex`~~\,\,\exp\left\{\,\mu + \frac{\sigma^2}{2}\,\right\} \approx ${ Math.round(Math.exp(param[0] + param[1] / 2) * 100) / 100 }`} *empirical* mean interarrival: ${tex`~~~~~~~~~~~~~~~~~~~~~~~~~~\,\,\,~~\approx`} ${tex`${ Math.round(diagram[1] * 100) / 100 }`}

*analytical* mean spread: ${tex`~~~~~~~~~\,\,\,\exp\left\{\mu + \frac{3\sigma^2}{2}\right\} \approx ${ Math.round(Math.exp(param[0] + (3 * param[1]) / 2) * 100) / 100 }`} *empirical* mean spread: ${tex`~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\,\,\,\,~~\,\,\,\approx`} ${tex`${ Math.round(diagram[2] * 100) / 100 }`}

`; break; case "chi-squared": return md`The **chi-squared distribution** is characterized by its *degrees of freedom* ${tex`\nu \in \mathbb{Z}_+`}. Its typical use case is as a pivotal distribution for various statistical tests and not as an interarrival distribution, but let's see how the inspection paradox holds up anyways. This is again a special case of the gamma distribution: ${tex`X \sim \chi^2_\nu \equiv \mathrm{Gamma}(\nu/2, 2)`}.

*analytical* mean interarrival: ${tex`~~~~~~~~~~~~\,\,\nu = ${param}`} *empirical* mean interarrival: ${tex`~~~~~\,\,\,\,\,\,~~~~\,\,\,\,~~\approx`} ${tex`${ Math.round(diagram[1] * 100) / 100 }`}

*analytical* mean spread: ${tex`~~~~~~~~~~~~\,\,\,\nu + 2 = ${ param + 2 }`} *empirical* mean spread: ${tex`~~~~~~~~~~~\,\,~~~~~~~~~~~~~ \approx`} ${tex`${ Math.round(diagram[2] * 100) / 100 }`}

`; case "exponential": return md`The **exponential distribution** is parameterized by a *rate* ${tex`\lambda > 0`}. Recall that a renewal process with exponentially-distributed interarrival times defines a (homogeneous) **Poisson process** with rate ${tex`\lambda`}, having the special property of "memorylessness". This is a special case of the gamma distribution: ${tex`X \sim \mathrm{Exponential}(\lambda) \equiv \mathrm{Gamma}(1, \lambda)`}.

*analytical* mean interarrival: ${tex`~~~~~~~~~~~~~ \frac1{\lambda} \approx ${ Math.round((1 / param) * 100) / 100 }`} *empirical* mean interarrival: ${tex`~~~~~~~~~~~~~~~\,~~\approx`} ${tex`${ Math.round(diagram[1] * 100) / 100 }`}

*analytical* mean spread: ${tex`~~~~~~~~~~~~~~~~~~~~\,\frac{2}{\lambda} \approx ${ Math.round((2 / param) * 100) / 100 }`} *empirical* mean spread: ${tex`~~~~~~~~~~~~~~~~~~~~~~~~\,\,\approx`} ${tex`${ Math.round(diagram[2] * 100) / 100 }`}

`; break; case "Erlang": return md`The **Erlang distribution** is another special case of the gamma distribution, and is parameterized by a *shape parameter* ${tex`k \in \mathbb{Z}_+`} and a *rate parameter* ${tex`\lambda > 0`}. If we have ${tex`\{X_1, X_2,\, \cdots, X_k\} \stackrel{\mathrm{\tiny{i.i.d.}}}{\sim} \mathrm{Exponential}(\lambda)`}, then ${tex`\sum_{i=1}^k X_i \sim \mathrm{Erlang}(k, \lambda)`}. The Erlang distribution is used to model the time until multiple "memoryless" events occur.

*analytical* mean interarrival: ${tex`~~~~~~~~~~~\,k\lambda = ${ Math.round(param[0] * param[1] * 100) / 100 }`} *empirical* mean interarrival: ${tex`~~~~~~~~~~~~~~~~\,\,\,\approx`} ${tex`${ Math.round(diagram[1] * 100) / 100 }`}

*analytical* mean spread: ${tex`~~~~~~~~\,\,(k+1)\lambda = ${ Math.round((param[0] + 1) * param[1] * 100) / 100 }`} *empirical* mean spread: ${tex`~\,~~~~~~~~~~~~~~~~~~~~~~~~\approx`} ${tex`${ Math.round(diagram[2] * 100) / 100 }`}

`; break; default: return md`you should not be reading this!`; } }35:T8f9,

# Generalization As we alluded to before, the inspection paradox as described here is only a special case of a more general phenomenon, all due to sampling bias. Some examples: * some university claims that their average class size is ${tex`n`}. You randomly sample some students and ask what their class sizes are, and the resulting average is ${tex`m > n`}. Is the university lying? Nope! (... at least not in this particular case.) The explanation is the same as above: the average class size as averaged over *classes* might be ${tex`n`}, but you're more likely to sample a student in a large class by virtue of that class being larger, and so more students are able to "represent" that particular class. Thus, our average class size over *students* will be greater than the true average. * this is known as the "friendship paradox". Ever feel like people you know have more friends than you do? Well, it might be true, but it's nothing to do with you. Again, the explanation is due to sampling bias. You are more likely to know a friend by virtue of them having friends! In other words, if someone does not have a lot of friends, they are not likely to have been friends with you in the first place. Therefore, if we randomly select a person and then randomly select one of their friends, their friend will have more friends on average than the person who was initially selected. ^{*credit to [Allen Downey](http://allendowney.blogspot.com/2015/08/the-inspection-paradox-is-everywhere.html) for the preceding examples; his blog post (which is linked) will contain some more.*}

# Conclusion As Downey mentions, the inspection paradox is truly *everywhere* — the "waiting time paradox" from above is just one instance of a seemingly ubiquitous phenomenon. Knowing about the paradox can help explain some counterintuitive results, and it showcases the power of good sampling design and how subtle sampling bias can be. Plus, it could still be a great excuse for being late... you really can't argue with math!

36:T1984,diagram = { const width = 900; const height = 300; const offset = 50; const width_ratio = 0.615; const svg = d3.create("svg").attr("viewBox", [0, 0, width, height]); let times = []; switch (mode) { case "log-normal": times = log_normal; break; case "exponential": times = exponential; break; case "Erlang": times = erlang; break; case "chi-squared": times = chi_squared; break; default: break; } let length = times.reduce((x, a) => x + a, 0); // from https://thewebdev.info/2022/01/15/how-to-do-partial-sums-of-array-items-in-javascript/ let partial_sums = times.reduce((acc, el, i, arr) => { const slice = arr.slice(0, i + 1); const sum = slice.reduce((a, b) => a + b, 0); return [...acc, sum]; }, []); let x = d3 .scaleLinear() .domain([0, length]) .range([0, width_ratio * width]); svg .append("g") .attr("transform", "translate(" + offset + "," + 0.9 * height + ")") .call(d3.axisBottom(x).ticks(10)) .selectAll("text") .attr("transform", "translate(0,0)") .style("text-anchor", "end"); svg .selectAll("lines") .data(partial_sums) .join("line") .attr("id", "times") .attr("x1", (d) => (d * width_ratio * width) / length + offset) .attr("y1", 0.9 * height - 5) .attr("x2", (d) => (d * width_ratio * width) / length + offset) .attr("y2", 0.9 * height + 5) .style("stroke", "#1b9e77") .style("stroke-width", sample_size > 30 ? 1 : 2) .style("opacity", 0); svg .selectAll("#times") .transition() .delay((d, i) => (i * 3000) / sample_size) .style("opacity", 1); // ======================================= HISTOGRAM: INTERARRIVAL TIMES ======================================== var x_hist = d3 .scaleLinear() .domain([0, d3.max(times) + 1]) .range([offset, 0.67 * width]); svg .append("g") .attr("transform", "translate(0," + (height / 2 + 50) + ")") .call(d3.axisBottom(x_hist)); // set the parameters for the histogram var histogram = d3 .histogram() .value((d) => d) .domain(x_hist.domain()) // then the domain of the graphic .thresholds(x_hist.ticks(d3.min([25, sample_size]))); // then the numbers of bins // apply this function to data to get the bins var bins = histogram(times); // Y axis: scale and draw: var y_hist = d3.scaleLinear().range([height / 2 + 50, 30]); y_hist.domain([0, d3.max(bins, (d) => d.length)]); // d3.hist has to be called before the Y axis obviously svg .append("g") .call(d3.axisLeft(y_hist)) .attr("transform", "translate(" + offset + ",0)"); // append the bar rectangles to the svg element svg .selectAll("rect.times") .data(bins) .enter() .append("rect") .classed("times", true) .attr("x", 1) .attr("transform", function (d) { return "translate(" + x_hist(d.x0) + "," + y_hist(d.length) + ")"; }) .attr("width", function (d) { return x_hist(d.x1) - x_hist(d.x0) - 1; }) .attr("height", function (d) { return 0; }) .style("fill", "#1b9e77") .style("opacity", 0.5); // ======================================= HISTOGRAM: SAMPLES ============================================== var t_sample = Array.from({ length: sample_size }, d3.randomUniform(length)); // get spreads from uniformly sampled times var spreads = Array(sample_size).fill(0); for (let i = 0; i < sample_size; i++) { let flag = false; for (let j = 0; j < sample_size; j++) { // defined by first range in which t > X_n if (t_sample[i] < partial_sums[j] && j === 0) { spreads[i] = partial_sums[0]; break; } else if (t_sample[i] < partial_sums[j] && j > 0) { spreads[i] = partial_sums[j] - partial_sums[j - 1]; break; } } } // set the parameters for the histogram var histogram_sample = d3 .histogram() .value((d) => d) .domain(x_hist.domain()) // then the domain of the graphic .thresholds(x_hist.ticks(d3.min([25, sample_size]))); // then the numbers of bins // apply this function to data to get the bins var bins_t = histogram_sample(spreads); svg .append("g") .call(d3.axisLeft(y_hist)) .attr("transform", "translate(" + offset + ",0)"); // append the bar rectangles to the svg element svg .selectAll("rect.sample") .data(bins_t) .enter() .append("rect") .classed("sample", true) .attr("x", 1) .attr("transform", function (d) { return "translate(" + x_hist(d.x0) + "," + y_hist(d.length) + ")"; }) .attr("width", function (d) { return x_hist(d.x1) - x_hist(d.x0) - 1; }) .attr("height", function (d) { return 0; }) .style("fill", "#7570b3") .style("opacity", 0.5); svg .selectAll("lines") .data(t_sample) .join("line") .attr("id", "t_sample") .attr("x1", (d) => (d * width_ratio * width) / length + offset) .attr("y1", 0.9 * height - 5) .attr("x2", (d) => (d * width_ratio * width) / length + offset) .attr("y2", 0.9 * height + 5) .style("stroke", "#7570b3") .style("stroke-width", sample_size > 30 ? 1 : 2) .style("opacity", 0); svg .selectAll("#t_sample") .transition() .delay((d, i) => 3800 + (i * 3000) / sample_size) .style("opacity", 1); // ========================================== HISTOGRAMS: TRANSITION =========================================== svg .selectAll("rect.times") .transition() .duration(800) .attr("y", function (d) { return y_hist(d.Value); }) .attr("height", function (d) { return height / 2 + 50 - y_hist(d.length); }) .delay(function (d, i) { return (i * 3000) / bins.length; }); svg .selectAll("rect.sample") .transition() .duration(800) .attr("y", function (d) { return y_hist(d.Value); }) .attr("height", function (d) { return height / 2 + 50 - y_hist(d.length); }) .delay(function (d, i) { return 3800 + (i * 3000) / bins_t.length; }); ////////////////////////////////////////////////////////////////////////////////////////////////////////////// // if (mode === "log-normal") { // let log_times = times.map((x) => Math.log(x)); // let log_spreads = spreads.map((x) => Math.log(x)); // return [svg.node(), Math.exp(mean(log_times)), Math.exp(mean(log_spreads))]; // } return [svg.node(), mean(times), mean(spreads)]; }37:[{"id":"903200b2f64dbba56ba33340e59214602ba8bbf103c171ffe4003be5a5f2efd17ed60a4dd7b4d9a33ffa94c64850c5bd73bc5f8fc0c4e1e93820753ee6fe94ea","href":"https://static.observableusercontent.com/files/903200b2f64dbba56ba33340e59214602ba8bbf103c171ffe4003be5a5f2efd17ed60a4dd7b4d9a33ffa94c64850c5bd73bc5f8fc0c4e1e93820753ee6fe94ea","name":"img_inspection.png","type":"image/png","lastModified":1650442028539.199,"size":109085}] 2e:{"title":"Playing the Waiting Game","cells":[{"id":0,"value":"$30","pinned":false,"hidden":false,"mode":"md"},{"id":9,"value":"$31","pinned":false,"hidden":false,"mode":"md"},{"id":168,"value":"$32","pinned":false,"hidden":false,"mode":"md"},{"id":616,"value":"\\lim\\limits_{t\\to\\infty}\\frac1{t} \\int\\limits_{0}^t A(s)\\, ds = \\frac{\\mathrm{E}[X^2]}{2\\mathrm{E}[X]} \\geq \\frac{\\mathrm{E}[X]}{2} ~~\\text{a.s.}\\\\[5pt]\n\\lim\\limits_{t\\to\\infty}\\frac1{t} \\int\\limits_{0}^t B(s)\\, ds = \\frac{\\mathrm{E}[X^2]}{2\\mathrm{E}[X]} \\geq \\frac{\\mathrm{E}[X]}{2} ~~\\text{a.s.}\\\\[5pt]\n\\!\\lim\\limits_{t\\to\\infty}\\frac1{t} \\int\\limits_{0}^t S(s)\\, ds \\,= \\frac{\\mathrm{E}[X^2]}{\\mathrm{E}[X]} \\geq \\,\\mathrm{E}[X] \\,~~\\text{a.s.}\n","pinned":false,"hidden":false,"mode":"tex"},{"id":654,"value":"$33","pinned":false,"hidden":false,"mode":"md"},{"id":579,"value":"# Simulation\n\nThis interactive simulation lets you explore the inspection paradox using various interarrival distributions. Most of them are special cases of the **gamma distribution**. \n\nThe mean spread converges to ${tex`\\frac{\\mathrm{E}[X^2]}{\\mathrm{E}[X]}`}, while the mean interarrival time is just ${tex`\\mathrm{E}[X]`}. How do the sample quantities computed from simulation compare to the theoretical results as the sample size (or equivalently, the length of the time horizon) increases?","pinned":false,"hidden":false,"mode":"md"},{"id":1315,"value":"viewof mode = Inputs.select(distributions, {\n value: \"exponential\",\n label: \"interarrival distribution\"\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1314,"value":"$34","pinned":false,"hidden":false,"mode":"ojs"},{"id":2133,"value":"viewof param = {\n switch (mode) {\n case \"log-normal\":\n return Inputs.form([\n Inputs.range([-1, 2], { step: 0.1, label: tex`\\mu` }),\n Inputs.range([0.1, 1], { step: 0.1, label: tex`\\sigma^2` })\n ]);\n break;\n case \"exponential\":\n return Inputs.range([0.1, 1], { step: 0.1, label: tex`\\lambda` });\n break;\n case \"Erlang\":\n return Inputs.form([\n Inputs.range([1, 10], { step: 1, label: tex`k` }),\n Inputs.range([1, 10], { step: 0.1, label: tex`\\lambda` })\n ]);\n break;\n case \"chi-squared\":\n return Inputs.range([1, 10], { step: 1, label: tex`\\nu` });\n break;\n default:\n break;\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":2354,"value":"viewof sample_size = Inputs.range([10, 1000], {\n min: 10,\n max: 1000,\n step: 10,\n value: 10,\n label: \"sample size\"\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":2371,"value":"diagram[0]","pinned":false,"hidden":false,"mode":"ojs"},{"id":14,"value":"$35","pinned":false,"hidden":false,"mode":"md"},{"id":2378,"value":"mean = (array) => array.reduce((a, b) => a + b, 0) / array.length","pinned":false,"hidden":false,"mode":"ojs"},{"id":1328,"value":"distributions = [\"log-normal\", \"exponential\", \"Erlang\", \"chi-squared\"]","pinned":false,"hidden":false,"mode":"ojs"},{"id":1112,"value":"// LOG-NORMAL\n// mu (log-mean), sigma (log-standard deviation)\n\nlog_normal = {\n let mu = param[0];\n let sigma = Math.sqrt(param[1]);\n\n return Array.from({ length: sample_size }, d3.randomLogNormal(mu, sigma));\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1127,"value":"// EXPONENTIAL\n// lambda (rate)\n\nexponential = {\n let lambda = param;\n\n return Array.from({ length: sample_size }, d3.randomExponential(lambda));\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1143,"value":"// GAMMA / ERLANG\n// k (shape), lambda (rate)\n\nerlang = {\n let k = param[0];\n let lambda = param[1];\n\n if (k > 0) {\n return Array.from({ length: sample_size }, d3.randomGamma(k, lambda));\n } else {\n return 0;\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1150,"value":"// CHI-SQUARED\n// nu (degrees of freedom)\n\nchi_squared = {\n let nu = param;\n\n let generate_chi_squared = function () {\n /* to generate a chi-squared random variable on nu degrees of freedom,\n we'll sum the squares of nu i.i.d. standard normal random variables */\n return (\n Math.hypot(...Array.from({ length: nu }, d3.randomNormal(0, 1))) ** 2\n );\n };\n\n return Array.from({ length: sample_size }, generate_chi_squared);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":1585,"value":"$36","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W37","stdlib":"1","titling":"auto"}