Skip to main content
100%

Simple functions to calculate expected number of failures and workload in systems that can process a given number of subscribers in parallel, using a binomial distribution model to simulate subscriber behavior. Applicable e.g. to web servers & cellphone base stations.

✓ Published0🌍 Public
Aadewes
Last edited Jul 29, 2013
Created on Jul 29, 2013

This example demonstrates how to estimate the expected workload and number of processing failures for a system with limited parallel capacity, such as a web server or cellphone base station. The code uses `scipy.stats.binom` to calculate the binomial probability mass function for each possible number of concurrent subscribers, then sums weighted contributions to derive the two metrics. The `workload` function computes the average percentage of capacity utilized, while `failures` sums the excess subscribers beyond the capacity limit. Both functions iterate over subscriber counts, applying the binomial distribution to model subscriber behavior at a given call probability.

AI-generated description

Similar vizzes

Loading thumbnail…

CSCE 5320 HW5 - Cloud Workload Performance

A scatterplot displays cloud workload performance, plotting monthly cost on the x-axis against throughput on the y-axis. Each circle represents a workload, with its area encoding active user count and its color indicating the cloud provider. The visualization uses d3.csv to load data from a GitHub gist and d3.scaleLinear, d3.scaleOrdinal, and d3.scaleSqrt to map the fields. A summary panel reports row counts, column names, cost range, and mean and median values using d3.mean and d3.median.

SSatya Tej Kammili
47% match
Loading thumbnail…

number exercises

This example visualizes the outcomes of several JavaScript exercise functions, each testing a specific computation. It shows whether functions like `computeArea`, temperature converters `celsToFahr` and `fahrToCels`, and `isDivisible` produce expected results. The code relies on native JavaScript functions and console logging to report pass or fail statuses, with no external libraries or data sources. The rendering approach is purely textual, using `console.log` output to display success or failure messages for each test case, making the results immediately visible in the console.

CCameron-Grams
44% match
Loading thumbnail…

Gist bc08c6f7041f76c33030f05231c99845

This visualization demonstrates the Central Limit Theorem by showing how sample means from non-normal population distributions converge to a normal sampling distribution. Three rows display the population distributions, individual sample points with their means overlaid, and histograms of the sampling distribution. The code uses Matplotlib to generate the figure, with statistical sampling performed via NumPy to simulate repeated sampling from each population and calculate the corresponding means.

TTheLady
43% match
Loading thumbnail…

Gist 9557217

This example simulates brain-volume measurements for healthy controls and multiple-sclerosis patients across two scan protocols, using synthetic data generated with NumPy and Statsmodels. It shows how measurement noise and protocol-related biases affect the relationship between age, disability scores, and brain volume. The visualization displays the simulated distributions and calibration results, with matplotlib and prettyplotlib rendering static plots. The code relies on inline plotting via `%pylab` and custom utility functions for distribution and calibration analysis, though no interactive or WebGL output is present in the provided notebook cells.

Aakeshavan
42% match
Loading thumbnail…

Gist b989c26735fde8214c19

This example demonstrates statistical power calculations for several genetic association models (DRAB1_sGMV, HLAB_ucca, HLAB_sGM, NFkb_WM) using R’s noncentral F distribution via the rpy2 interface, with power derived from effect sizes and sample sizes listed in a pandas DataFrame. It imports the `stats` package and uses `statsmodels.api` alongside scipy.stats, defining a custom `pf` function that calls R’s `qf` and `pf` functions to compute critical values and noncentral power. The notebook also loads precomputed intraclass correlation coefficients from a pickled file and displays the power table as an HTML-rendered pandas DataFrame.

Aakeshavan
42% match
Loading thumbnail…

Gist 9556811

This example simulates brain volume and disability data for healthy controls and multiple sclerosis patients across two sites, generating synthetic datasets with site-specific EDSS distributions. It uses Python with statsmodels and matplotlib via prettyplotlib to plot the simulated distributions, including scatterplots and regression fits that illustrate relationships between age, brain volume, and EDSS scores. The visualization is part of a Vue-based gallery, but the core computation and plotting rely on numpy and statsmodels for statistical simulation and visualization.

Aakeshavan
42% match
Loading thumbnail…

Gist 55a48fa82777d6887803eee74a1ed490

This visualization tracks Kafka client health by counting log occurrences of producer attempts, successes, and failures. It uses a shell script with `grep` and `grep -c` to extract counts from the `/srv/minted/logs/www-wsgi.log` file every second, then prints the ratio of sent to attempted messages. The script loops indefinitely with `while sleep 1`, providing a live textual readout rather than a graphical plot. The example relies solely on command-line text processing, not any visualization library.

Aamazingandyyy
42% match
Loading thumbnail…

Shows an example how a task can be submitted N times for retries and an await block to ensure all of the tasks are completed.

This example demonstrates a robust retry mechanism for asynchronous task execution, where a task submitted up to three times eventually succeeds after initial failures, with an await block ensuring all tasks complete before results are collected. It shows how `FixedExecutionRunnable` wraps a `Callable` using `ScheduledExecutorService`, `CountDownLatch`, and `ScheduledFuture` to schedule retries at fixed delays, while `DummyCallable` throws exceptions on the first two attempts. The code uses Scala collections like `ListBuffer` and `AtomicInteger` to simulate three concurrent task submissions, verifying the final output matches the expected task names.

AAyanGhatak
42% match