Network-Calculus is the mathematical formalism under the hood of many timing verification algorithms, and it has been for instance used for the design and certification of avionics AFDX networks for the last 15 years. Our RTaW-Pegase tool relies on Network-Calculus to predict the worst-case behavior of networks.

Underlying Network Calculus is the (min,+) algebra. To learn the (min,+) algebra, or to develop new Network-Calculus timing verification algorithms, we need a (min,+) algebra interpreter that should be both easy to use, with graphical outputs to quickly understand the results of calculations, and comprehensive in terms of the mathematical operators available.

We have made our state-of-the-art (min,+) algebra interpreter freely available for research and teaching since 2010. We are today glad to release the (min,+) Playground, which is a web service that allows to write and execute (min,+) algebra calculations without any installation.

Your feedback and suggestions are most welcome to help us improve the (min,+) Playground. If you’d intend to teach Network Calculus / (min,+) algebra, we may point you out to good resources since some of our academics partners have experienced in that.

To get you started, you’ll find on this page a quick reference guide listing the mathematical functions and operators available in the interpreter. You can also execute the (min,+) script below by clicking on the Run button.

### Function constructors

```
// Create three affine functions:
f := affine(7/4, 2)
g := affine(4/5, 3)
h := affine(2/5, 5)
// and use them to create an arrival function defined as their minimum:
arrival := f /\ g /\ h
// Plot the arrival function and the affine functions from which it has been defined:
plot(arrival, f, g, h)
// Create a "rate latency" service function: we need to take the maximum with
// a horizontal line to obtain the first horizontal segment:
service1 := affine(2, -4) \/ affine(0, 0)
// Plot the service function:
plot(service1)
plot(arrival, service1)
// Create some other service function:
service2 := affine(3.1, -12) \/ affine(0, 0)
plot(service2, service1, xlim=[-0.3, 15], ylim=[-0.3, 15])
// Compute the difference between two functions:
service3 := service1 - service2
plot(service3, service1, service2)
// Compute the convolution of two service functions:
convService := service1 * service2
plot(convService, service2, service1)
// Compute the convolution of two arrival functions:
convArrival := f * g
plot(convArrival, f, g)
// Compute the deconvolution of an arrival function by a service function:
deconf := arrival / service1
plot(deconf, arrival)
// Compute the subadditive closure:
closure := star(deconf)
plot(deconf, closure)
```

## Leave A Comment