Probly is a Python-like mini-language for probabilistic estimation. It's based on Starlark and implemented in Go.
You may use any Starlark syntax. There are only the following differences to Starlark:
math
module is imported by default, so you can directly use it e.g. math.sqrt(2)
. Probly also has a built-in sum
function not available in Starlark.This page will show you the probability distributions of all the numeric (scalar or distribution) global variables in your program (except those starting with an underscore). The values are taken at the end of the program's execution.
Name | to p10 to p90 |
pm plus/minus |
td times/divide |
Quantiles | Notes | |||||
---|---|---|---|---|---|---|---|---|---|---|
Normal |
mean |
sd |
2 | |||||||
LogNormal |
mu |
sigma |
2 | Alternatively: mean , sd |
||||||
Beta |
alpha |
beta |
||||||||
PERT |
min |
mode |
max |
[lambd] |
Like the triangular, but smoother (Wikipedia) | |||||
Uniform |
a |
b |
2 | a need not be less than b |
||||||
LogUniform |
a |
b |
2 | a need not be less than b |
||||||
Bernoulli |
p |
|||||||||
Binomial |
n |
p |
||||||||
Discrete |
x_1 |
p_1 |
x_2 |
p_2 |
... | Generic discrete distribution over any finite set of values |
These mathematical functions and constants are available in the math
module:
pow(x, y)
- Returns x raised to the power of yexp(x)
sqrt(x)
log(x, [base])
- Natural logarithm by default if base is not specifiede
pi
ceil(x)
floor(x)
fabs(x)
- Returns the absolute value of x as floatcopysign(x, y)
- Returns a value with the magnitude of x and the sign of ymod(x, y)
- Returns x
modulo y
remainder(x, y)
round(x)
- Returns the nearest integer, rounding half away from zeroacos(x)
asin(x)
atan(x)
atan2(y, x)
- Returns atan(y / x). The result is between -pi and picos(x)
sin(x)
tan(x)
degrees(x)
- Converts angle x from radians to degreesradians(x)
- Converts angle x from degrees to radiansacosh(x)
asinh(x)
atanh(x)
cosh(x)
sinh(x)
tanh(x)
hypot(x, y)
- Returns the Euclidean norm, sqrt(x^2 + y^2); the distance from the origin to (x, y)gamma(x)
- Returns the Gamma function at xThis code provides an example of the syntax of Starlark:
# Define a number
number = 18
# Define a list
numbers = [1, 2, 3, 4, 5]
# List comprehension
halves = [n / 2 for n in numbers]
# Define a function
def is_even(n):
"""Return True if n is even."""
return n % 2 == 0
# Define a dictionary
people = {
"Alice": 22,
"Bob": 40,
"Charlie": 55,
"Dave": 14,
}
names = ", ".join(people.keys()) # Alice, Bob, Charlie, Dave
# Modify a variable in a loop
sum_even_ages = 0
for age in people.values():
if is_even(age):
sum_even_ages += age
# Append to a list in a loop
over_30_names = []
for name, age in people.items():
if age > 30:
over_30_names.append(name)
If you've ever used Python, this should look very familiar. In fact, the code above is also valid Python code. Still, this short example shows most of the language. Starlark is a very small language that implements a limited subset of Python.
For our purposes, one notable difference to Python is that the exponentiation operator **
is not supported. You have to use math.pow
.
You can also look at the Starlark language specification.
Though not designed for speed, Probly is fast enough for practical purposes: around 10 milliseconds for 3,000 samples, for most examples on this page. This is due to being implemented in Go.
The time taken to return results on this page is spent overwhelmingly in web application code, not in Probly evaluation.
Interestingly, Probly is still slower than Python code that uses entirely numpy
array operations, which are very well optimised.
This should only begin to matter at very large scales, or if latency is critical.
It's not currently possible to obtain and manipulate properties of a distribution within an Probly program, like so:
x = Normal(1 to 10)
y = x.std() # Not possible
Supporting this would require some fundamental changes to the implementation of Probly, which is currently very simplistic.
The to
binary operator was inspired by Squiggle.
In the famous Monty Hall problem, you are given the choice of three doors. Behind one door is a car; behind the others, goats. You pick a door, say No. 1, and the host, who knows what's behind the doors, opens another door, say No. 3, which has a goat. He then says to you, "Do you want to pick door No. 2?" Is it to your advantage to switch your choice?
The answer is that you should always switch. This example demonstrates it by simulation.
In our model, a payoff of 0
represents a goat and 1
represents the car. The switch payoff distribution has a 2/3 probability of winning the car (vs 1/3 without switching). Its expectation is about 0.66.
Mean | 0.670 |
Std. dev. | 0.470 |
Variance | 0.221 |
Quantile | |
---|---|
0.05 | 0 |
0.25 | 0 |
0.50 | 1.00 |
0.75 | 1.00 |
0.95 | 1.00 |
Mean | 2.01 |
Std. dev. | 0.807 |
Variance | 0.652 |
Quantile | |
---|---|
0.05 | 1.00 |
0.25 | 1.00 |
0.50 | 2.00 |
0.75 | 3.00 |
0.95 | 3.00 |
Mean | 2.00 |
Std. dev. | 0.814 |
Variance | 0.662 |
Quantile | |
---|---|
0.05 | 1.00 |
0.25 | 1.00 |
0.50 | 2.00 |
0.75 | 3.00 |
0.95 | 3.00 |
car_door | our_door | switch_payoff | |
---|---|---|---|
0 | 2.00 | 3.00 | 1.00 |
1 | 2.00 | 3.00 | 1.00 |
2 | 2.00 | 2.00 | 0 |
... | ... | ... | ... |
2997 | 2.00 | 1.00 | 1.00 |
2998 | 3.00 | 1.00 | 1.00 |
2999 | 2.00 | 3.00 | 1.00 |
Get the simulation data (and more) in a machine-readable format:
/api/sim/QTdK38zKKmNahcHcyPQZKU/