Repository and Blackbox reliability challenge 2019Â¶
This website contains a series of benchmark problems for testing reliability analysis methods. It consists of two main parts:
 A repository for the Blackbox Reliability Challenge 2019;
 A reliability problem repository for benchmarking structural reliability method.
Note
We are looking for volunteers to organize the next reliability challenge. If you are interested to lead or participate in the organization, have suggestions on how to improve and extend the challenge, and/or would like to donate reliability problems, please contact us (email).
Note
The challenge is closed (see the Results) but you can still use the server. If you have any questions or suggestions feel free to contact us via email or Git Issues.
IntroductionÂ¶
What is this?Â¶
Blackbox Reliability Challenge 2019 is a challenge and framework to test the performance of structural reliability methods. It is the first challenge in structural reliability where the reliability problems are truly black boxes for participants, meaning that their performance functions are hidden from the participants by making them accessible via the internet in the form of submitted input arguments and received output. To our knowledge, it is also the first online challenge in structural reliability. It is inspired by blackbox optimization competitions such as BBComp. After the challenge, all the details of the reliability problems will be made publicly available, moving them to the repository for the structural reliability benchmarking framework.
We intend the current challenge to be the first iteration which we wish to improve based on the gained experience and your feedback. We are indebted to those who have already contributed to the design of the challenge and collecting reliability problems. We hope that the challenge and repository will evolve into an open, community project!
MotivationÂ¶
Over the last decades, a plethora of reliability analysis methods has been developed with various capabilities, accuracy, and efficiency. Yet, an objective comparison and evaluation of these methods is missing. The currently available comparative studies are limited in scope and do not allow impartial analysis as only the final results are disclosed and they allow unrealistic exploration of the reliability problem by the analyst.
Here we propose a testing framework which is designed to:
 deliver the longneeded, systematic and structured comparison of the performance of reliability algorithms among simplified, academic problems and reallife engineering problems;
 provide invaluable guidance for practical applications of reliability analysis in the domains of geotechnical engineering, hydraulic engineering, structural engineering, and earthquake engineering; and
 aid setting future research directions.
TimelineÂ¶
Phase  Start date  End date 

Workshop [Rozsas2018]  2018Jan24  NA 
Announcement & test problems  2018Dec21  NA 
Challenge  2019March28  2019Dec04 
Announcement of results (Results)  2019Dec20  NA 
Followup workshop  2020Feb24  2020Feb25 
How to participateÂ¶
Everyone is welcome to join the challenge (registration will open in early 2019). The participants use their computer and their selected method to solve reliability problems with performance functions located on the organizers servers. See the Quick start for a walk through how to do this.
Who we areÂ¶
The idea of the Blackbox Reliability Challenge, the benchmarking framework, and the reliability problem types are the outcome of a joint discussion and followup sessions between the participants of a workshop held in 2018 in Delft [Rozsas2018].
The organization and implementation of the challenge are spearheaded by the Department of Structural Reliability, TNO. The members of the team have selected the reliability problems which are known exclusively to them until the announcement of the results.
ResultsÂ¶
Thank you everyone who participated in, contributed to, and/or was interested in the Blackbox Reliability Challenge 2019. As a first step of disseminating the results we:
 made all reference solutions and performance functions public, see Reliability problems;
 summarize the main results in the plots below (participants are anonymized) (Visual summary);
 made the web server code (framework) publicly available.
If you use some code or results from this website please cite us (Citation).
If you have any suggestions and/or questions regarding the results or about the reliability challenge in general, do not hesitate to Contact us.
Next stepsÂ¶
We organized a followup workshop that took place in Delft, the Netherlands on the 2425th of February 2020. During the workshop the participants shared the details of their reliability algorithms and their experience for the benefit of the reliability community. For more information  including the presentations and summary of the workshop  visit the website of the workshop.
We plan to write up the main outcomes of the workshop into a brief report and make it available on the website of the workshop. Moreover, we plan to disseminate the results via journal paper(s).
Note
We are looking for volunteers to organize the next reliability challenge. If you are interested to lead or participate in the organization, have suggestions on how to improve and extend the challenge, and/or would like to donate reliability problems, please contact us.
ParticipationÂ¶
Everyone is welcome to join the challenge. There are two ways to access the reliability problems on the challenge server:
 Without registration: using the
testuser
credentials given in Tutorial set. Without registration you have access only to the tutorial problems. To get full access you need to register, see the next point.  With registration: to get full access to the reliability problems and to participate in the challenge.
RegistrationÂ¶
Note
The challenge is closed but you can still register to access the reliability problem!
You can register by sending an email to us expressing your intent. You will receive your username
, password
, and user_id
which you can use to interact with the web server (see Quick start).
Please keep the following in mind:
 In the email please indicate your name and affiliation (teams can also participate).
 Use the following subject line in the email: Registration Blackbox Reliability Challenge 2019.
 One person is allowed to register only once (or part of only a single team).
 Do not share your results and/or performance function evaluations with other participants.
We expect you to play fair and adhere to the single registration and not sharing principles. It is in our common interest to have everyone the same information available. After the completion of the challenge we will invite the participants to share their algorithms where others can verify the results.
ContributionÂ¶
We would love to hear your opinion, suggestions, and have you contributing to this project. Please do not hesitate to contact us if you:
 have any questions or issues;
 have any suggestions;
 would like to donate a reliability problem or two;
 would like to contribute to the code.
You can get in touch via email or Git Issues. You can also directly contribute to the GitLab repository following the standard git procedure.
Quick startÂ¶
This section walks you through the steps of evaluating performance functions and submitting results within the challenge framework.
We provide a Python and a Matlab tutorial as well, pick the one you prefer.
PythonÂ¶
The most important actions you have to be familiar with to successfully participate in the challenge are:
Evaluate evaluates a performance function on the web server, while Submit submits your intermediate and/or final results such as reliability indices and sensitivity factors to the server. Note that is of utmost importance that you also submit your intermediate results so we can compare the rate of convergence of different methods.
You need to have a Python installation (either 2.x or 3.x will work).
EvaluateÂ¶
Download our evaluate.py file that manages the communication with the server and put into a folder of your choice.
Warning
GitLab will propose a filename that contains the path, rename it to evaluate.py
.
Set the working directory of Python to this folder and open a new pyfile (script) [*]. If you do not have the requests package installed (pip install requests
) then install it as the Python files rely on it.
First, we need to provide our username
and password
. Once the challenge is open (Timeline) you can register and use your username and password to access the performance functions. For testing purposes letâ€™s use a predefined, test user account:
username = 'testuser'
password = 'testpass'
Then we need some ids to uniquely identify our performance function. Letâ€™s pick the second problem from the â€“ Tutorial set.:
set_id = 1
problem_id = 2
Problem 2 is corresponding to RP22 that is a twodimensional, nonlinear function.
The next step is to specify the location where we would like to evaluate the performance function. The location is the independent variable of the function and we define it as a list with numerical items (you can also use a numpy array and bundle (vectorized) calls are also possible Evaluate):
x = [0.545, 1.23]
Now we have everything to evaluate the performance function. First we need to import the earlier downloaded evaluate.py
function:
from evaluate import evaluate
Then we can use it to evaluate the performance function:
g_val_sys, g_val_comp, msg = evaluate(username, password, set_id, problem_id, x)
print(msg)
print(g_val_sys)
print(g_val_comp)
Where g_val_sys
is the performance function value on system level and g_val_comp
contains a performance function value for each component involved in the problem. For cases with a single performance function (as this one) g_val_sys=g_val_comp
.
Executing the above code prints the following to the command window:
Ok
1.2918
[1.2918]
Congratulations! You just evaluated a performance function on our server! Go ahead and test the function with other inputs, incorrect input, and try our other functions as well.
For using the performance function in your reliability algorithm you can wrap the above code into a function or you can create a lambda function that fits your reliability algorithm, e.g.
def g_fun(x):
g = evaluate(username, password, set_id, problem_id, x)
return g
Given that within this challenge we intentionally cap your number of performance function evaluations you might wonder how many evaluations you have left. You can check this by clicking on this link. The request_limit
is set to 1 for this tutorial example which means that there is no upper limit so you can experiment with these functions. However, for the problems included in the challenge finite limits are enforced. Once you registered you will have your dedicated page to check your submissions.
[*]  You can download a file with all the code above from the GitLab repository: tutorial_evaluate.py. 
SubmitÂ¶
After evaluating a performance function multiple times you might want to submit your intermediate or final results to the server to be compared with other participants. This section shows you how to do that. Note that you have to submit at least one result for a problem to be considered among the participants. Results submitted via other means than that described below are not accepted. You are strongly encouraged to submit your intermediate results as well since that will give us an idea about the rate of convergence of your method.
For submitting result you need to download the submit.py file. Save it into your working directory. For illustrative purposes letâ€™s make a dummy a submission with the following input (you can use numpy arrays as well):
from submit import submit
username = 'testuser'
password = 'testpass'
set_id = 1
problem_id = 2
beta_sys = 3.4
beta_comp = 3.4
alpha_sys = []
alpha_comp = [0.64, 0.77]
You have to identify yourself and specify the particular set and problem you are submitting the results to. Note that some inputs are optional, e.g. alpha_sys
is left empty in this case. The results can submitted by using the submit
function:
msg = submit(username, password, set_id, problem_id, beta_sys, beta_comp, alpha_sys, alpha_comp)
print(msg)
To check your submission online, in the database of the web server click on this link.
MatlabÂ¶
The most important actions you have to be familiar with to successfully participate in the challenge are:
Evaluate evaluates a performance function on the web server, while Submit submits your intermediate and/or final results such as reliability indices and sensitivity factors to the server. Note that is of utmost importance that you also submit your intermediate results so we can compare the rate of convergence of different methods.
You need to have a Matlab installation (version R2015a or above).
EvaluateÂ¶
Download our evaluate.m file that manages the communication with the server and parse_json.m that is used to postprocess the response from the server. Put both files into a folder of your choice.
Warning
GitLab will propose a filename that contains the path, rename it to evaluate.m
.
Set the working directory of Matlab to this folder and open a new mfile (script) [â€ ].
First we need to provide our username
and password
. Once the challenge is open (Timeline) you can register and use your username and password to access the performance functions. For testing purposes letâ€™s use a predefined, test user account:
username = 'testuser';
password = 'testpass';
Then we need some ids to uniquely identify our performance function. Letâ€™s pick the second problem from the tutorial set (see â€“ Tutorial set. for further details):
set_id = 1;
problem_id = 2;
Problem 2 is corresponding to RP22 that is a twodimensional, nonlinear function.
The next step is to specify the location where we would like to evaluate the performance function. The location is the independent variable of the function and we define it as a numerical vector (bundle (vectorized) calls are also possible by using matrices Evaluate):
x = [0.545, 1.23];
Now we have everything to evaluate the performance function for which we are going to use the earlier downloaded evaluate.m
function:
[g_val_sys, g_val_comp, msg] = evaluate(username, password, set_id, problem_id, x);
disp(msg)
disp(g_val_sys)
disp(g_val_comp)
Where g_val_sys
is the performance function value on system level and g_val_comp
contains a performance function value for each component involved in the problem. For cases with a single performance function (as this one) g_val_sys=g_val_comp
.
Executing the above code prints the following to the command window:
Ok
1.2918
1.2918
Congratulations! You just evaluated a performance function on our server! Go ahead and test the function with other inputs, incorrect input, and try our other functions as well.
For using the performance function in your reliability algorithm you can wrap the above code into a function or you can create a anonymous function that fits your reliability algorithm, e.g.
g_fun = @(x) evaluate(username, password, set_id, problem_id, x);
Given that within this challenge we intentionally cap your number of performance function evaluations you might wonder how many evaluations you have left. You can check this by clicking on this link. The request_limit is set to 1 for this tutorial example which means that there is not upper limit so you can experiment with these functions. However, for the problems included in the challenge finite limits are enforced.
[â€ ]  You can download a file with all the code above from the GitLab repository: tutorial_evaluate.m. 
SubmitÂ¶
After evaluating a performance function multiple times you might want to submit your intermediate or final results to the server to be compared with other participants. This section shows you how to do that. Note that you have to submit at least one result for a problem to be considered among the participants. Results submitted via other means than that described below are not accepted. You are strongly encouraged to submit your intermediate results as well since that will give us an idea about the rate of convergence of your method.
For submitting result you need to download the submit.m file. Save it into your working directory. For illustrative purposes letâ€™s make a dummy a submission with the following input:
username = 'testuser';
password = 'testpass';
set_id = 1;
problem_id = 2;
beta_sys = 3.4;
beta_comp = 3.4;
alpha_sys = [];
alpha_comp = [0.64, 0.77];
You have to identify yourself and specify the particular set and problem you are submitting the results to. Note that some inputs are optional, e.g. alpha_sys
is left empty in this case. The results can submitted by using the submit
function:
msg = submit(username, password, set_id, problem_id, beta_sys, beta_comp, alpha_sys, alpha_comp);
disp(msg)
To check your submission online, in the database of the web server click on this link.
Server interactionÂ¶
This section summarizes how to interact with the server. It serves two purposes:
 a cheatsheet like refresher of the functionalities and their usage;
 a detailed description of the functionalities.
The server code is MITlicensed and the source is available from GitLab.
CheatsheetÂ¶
Server domain:
https://tnoblackboxchallengeapi.herokuapp.com
Action  How  Details 

register  via email, provide your name and affiliation  Participation 
evaluate 
evaluate(...).py/m 
Evaluate 
submit 
submit(...).py/m 
Submit 
show budget  /showmybudget?user_id=<string> 
Show budget 
show submissions  /showmysubmissions?user_id=<string>&set_id=<integer>&problem_id=<integer> 
Show submissions 
Language  Version  Remark 

Python  2.x or 3.x  utility functions provided 
Matlab  R2015a or above  utility functions provided 
Other language  user has to make utility functions 
DetailsÂ¶
EvaluateÂ¶
PythonÂ¶

evaluate
(username, password, set_id, problem_id, x)[source]Â¶ Evaluate a performance function
Parameters:  username (str) â€“ Registered username for authentication. For testing without registration use â€˜testuserâ€™.
 password (str) â€“ Registered password for authentication. For testing without registration use â€˜testpassâ€™.
 set_id (int) â€“ Identification number of the problem set.
 problem_id (int) â€“ Identification number of the problem.
 x (list, numpy.array) â€“ Values of independent variables/random variables where the performance function is evaluated. Columns are the values of random variables (x1, x2,â€¦xn). Bundle (vectorized) call is possible by providing multiple rows, each corresponds to one set of values of the random variables.
Returns:  g_val_sys (list (numpy.array)) â€“ Performance function value on system level.
 g_val_comp (list (numpy.array)) â€“ Performance function value for each component.
 msg (str) â€“ Diagnostic message.
Examples
>>> g_val_sys, g_val_comp, msg = evaluate(username='testuser', password='testpass', set_id=1, problem_id=2, x=[0.545, 1.23]) >>> print(g_val_sys) 1.2918
MatlabÂ¶
See evaluate.m and parse_json.m on GitLab.
HTTP POST requestÂ¶
https://tnoblackboxchallengeapi.herokuapp.com/evaluate
Key  Value  Value example 

username 
<string with quotes>  â€˜testuserâ€™ 
password 
<string with quotes>  â€˜testpassâ€™ 
set_id 
<integer>  1 
problem_id 
<integer>  2 
input_list 
<numbers in square bracket(s)>  [0.545, 1.23] and [[0.545, 1.23], [0.6, 1.1]] 
input_list
contains values of independent variables/random variables where the performance function is evaluated. Columns are the values of random variables (x1, x2,â€¦xn). Bundle (vectorized) call is possible by providing multiple rows, each corresponds to one set of values of the random variables.
{
"username": "testuser",
"password": "testpass",
"set_ID": 1,
"problem_ID": 2,
"input_list": [0.545, 1.23]
}
The request returns the following JSON structure:
Key  Value  Value example 

g_val_sys 
<snumbers in square bracket(s)>  [2.32] 
g_val_comp 
<snumbers in square bracket(s)>  [2.32, 5.76] 
msg 
<string with quotes>  â€˜Okâ€™ 
{
"g_val_sys": [2.32],
"g_val_comp": [2.32, 5.76],
"msg": "Ok"
}
SubmitÂ¶
PythonÂ¶

submit
(username, password, set_id, problem_id, beta_sys, beta_comp=None, alpha_sys=None, alpha_comp=None)[source]Â¶ Evaluate a performance function
Parameters:  username (str) â€“ Registered username for authentication. For testing without registration use â€˜testuserâ€™.
 password (str) â€“ Registered password for authentication. For testing without registration use â€˜testpassâ€™.
 set_id (int) â€“ Identification number of the problem set.
 problem_id (int) â€“ Identification number of the problem.
 beta_sys (float) â€“ System reliability index.
 beta_comp (list of float) â€“ Vector of reliability indices. Leave it empty [] if you do not want to submit it.
 alpha_sys (list of float) â€“ Vector of sensitivity factors. Leave it empty [] if you do not want to submit it.
 alpha_comp (list of (list of) float) â€“ Matrix of sensitivity factors. Each row is a vector component sensitivity factors. Leave it empty [] if you do not want to submit it.
Returns: msg â€“ Accompanying diagnostic message, e.g. warning.
Return type: str
Examples
>>> msg = submit(username='testuser', password='testpass', set_id=1, problem_id=3, beta_sys=3.4, beta_comp=np.array([3.4, 4.5]), alpha_sys=None, alpha_comp=np.array([[0.64, 0.77], [0.84, 0.54]])) >>> print(msg)
HTTP POST requestÂ¶
https://tnoblackboxchallengeapi.herokuapp.com/submit
Key  Value  Value example 

username 
<string with quotes>  â€˜testuserâ€™ 
password 
<string with quotes>  â€˜testpassâ€™ 
set_id 
<integer>  1 
beta_sys 
<number>  3.4 
beta_comp 
<numbers in square bracket(s)>  [3.4, 4.5] 
alpha_sys 
<numbers in square bracket(s)>  [] 
alpha_comp 
<numbers in square bracket(s)>  [[0.64, 0.77], [0.84, 0.54]] 
{
"username": "testuser",
"password": "testpass",
"set_ID": 1,
"problem_ID": 3,
"beta_sys": 3.4,
"beta_comp": [3.4, 4.5],
"alpha_sys": [],
"alpha_comp": [[0.64, 0.77], [0.84, 0.54]]
}
Show budgetÂ¶
HTTP GET requestÂ¶
Paste the URL below to the URL bar of your browser:
https://tnoblackboxchallengeapi.herokuapp.com/showmybudget?user_id=testid
Key  Value  Value example 

user_id 
<string without quotes>  testid 
If you are registered to challenge you can use your user_id
to check your consumed and available budget.
Show submissionsÂ¶
HTTP GET requestÂ¶
The server records all requests: x
, g_val_sys
, and g_val_comp
values. This makes it possible to retain earlier evaluations in case your algorithm or computer crashed in the middle of the analysis and you lost the intermediate results.
Paste the URL below to the URL bar of your browser:
https://tnoblackboxchallengeapi.herokuapp.com/showmysubmissions?user_id=testid&set_id=1&problem_id=3
Key  Value  Value example 

user_id 
<string without quotes>  testid 
set_id 
<integer>  1 
problem_id 
<integer>  3 
If you are registered to the challenge you can use your user_id
to check your submissions.
Challenge problemsÂ¶
OverviewÂ¶
The reliability problems â€“ grouped into different sets â€“ are summarized in the tables below. The sets are established to represent distinctively different problems where different methods are expected to excel, e.g. reliability problems with a single design point, or reliability problems with continuous and differentiable performance function. Sets and problems are identified with their set_id
and problem_id
, respectively; both are integers.
You can download all of the probabilistic models from the GitLab repository in a tabular format by clicking on this link.
Problem setsÂ¶
Tutorial setÂ¶
To help the understanding and verification purposes all details are disclosed for the first two problems in this set. Problem 3 exemplifies what information will be provided during the challenge for each reliability problems. Since these problems serve testing, no upper limit on the number of performance function evaluations is enforced. Use username: 'testuser'
and password: 'testpass'
for testing (only available for the tutorial).
username 
â€˜testuserâ€™ 
password 
â€˜testpassâ€™ 
set_id 
problem_id 
Reliability problem  Max evaluations 

1  1  RP8  \(\infty\) 
1  2  RP22  \(\infty\) 
1  3  RP33  \(\infty\) 
Challenge set 1  single performance functionÂ¶
Reliability problems in this set have a single performance function but nothing else is disclosed about them. Once the challenge is open (Timeline) you can register and use your username and password to access these problems.
Evaluating the performance function yields a component and a system performance function value. These are equal as we have only a single performance function.
Note
Some of the performance functions rely on iterative numerical algorithms which might fail to converge under certain inputs; similarly as a finite element analysis. In those cases NaN values are returned. Make sure that your reliability algorithm can handle these cases. The performance functions will not yield NaN values for reasonable input points that do not correspond to failure.
set_id 
problem_id 
Reliability problem  Max evaluations 

1  1  RP14  10000 
1  2  RP24  10000 
1  3  RP28  10000 
1  4  RP31  10000 
1  5  RP38  10000 
1  6  RP53  10000 
1  7  RP54  10000 
1  8  RP63  10000 
1  9  RP75  10000 
1  10  RP107  10000 
1  11  RP111  10000 
1  12  RP201  10000 
1  13  RP203  10000 
1  14  RP213  10000 
1  15  RP300  10000 
1  16  RP301  10000 
Challenge set 2  Multiple, known number of performance functionsÂ¶
Reliability problems in this set have unknown number of performance functions. Once the challenge is open (Timeline) you can register and use your username and password to access these problems.
Evaluating the performance function yields performance function values for each component and the system as well. However, how the system performance function is calculated is not revealed, you test the RP33 system problem from the tutorial set.
Note
Some of the performance functions rely on iterative numerical algorithms which might fail to converge under certain inputs; similarly as a finite element analysis. In those cases NaN values are returned. Make sure that your reliability algorithm can handle these cases.
set_id 
problem_id 
Reliability problem  Max evaluations 

2  1  RP25  10000 
2  2  RP33  10000 
2  3  RP35  10000 
2  4  RP55  10000 
2  5  RP57  10000 
2  6  RP60  10000 
2  7  RP77  10000 
2  8  RP89  10000 
2  9  RP91  10000 
2  10  RP110  10000 
2  11  RP202  10000 
Challenge detailsÂ¶
Accessing performance functionsÂ¶
The performance functions are located on a cloud server managed by the organizers. The functions are evaluated upon a request by the participants (Fig. 4). The evaluation request (interfacing with the server) is a HTTP (Hypertext Transfer Protocol) request that is the backbone of modern web development and ubiquitous in distributed system communication [Podila2013].
If you are using Python or Matlab you do not have to know anything about HTTP request as we created an easytouse function in each of these languages to access the performance functions on our server (see Evaluate). If you are using another language then you have to have a basic familiarity with HTTP, see Other languages.
Other languagesÂ¶
If you are using a language other than Python or Matlab, or you want to make your own request directly you have to
make a HTTP POST request with a JSON body to our server. The URL for the POST request:
https://tnoblackboxchallengeapi.herokuapp.com/evaluate
. It should contain a JSON body with the following
fields (the values are taken from Quick start):
{
"username":'testuser',
"password":'testpass',
"set_ID": 1,
"problem_ID" : 2,
"input_list" : [0.545, 1.23]
}
The server returns a JSON file with 'msg'
, 'g_val_sys'
, and 'g_val_comp'
fields.
The web serverÂ¶
The web server is hosted in the cloud by the challenge organizers and can be accessed via HTTP request. It is a Flask The server code is MITlicensed and the source is available from GitLab. server. After the closure of the challenge of 2019 we opensourced the server that can be pulled from GitLab.
Frequently asked questionsÂ¶
 Can I submit multiple evaluation requests simultaneously?
Yes. Bundle (vectorized) call is possible by providing multiple rows in
input_list
, each corresponds to one set of values of the random variables. Columns are the values of random variables (\(x_1, x_2,\cdots x_n\)). For example making three evaluation requests of a twodimensional problem: in Python: input_list =
[[0.545, 1.23], [0.6, 1.1], [0.4, 1.6]]
ornumpy.array([[0.545, 1.23], [0.6, 1.1], [0.4, 1.6]])
 in Matlab: input_list =
[0.545, 1.23; 0.6, 1.1; 0.4, 1.6]
 in Python: input_list =
 What if Iâ€™m using a programming language other than Python or Matlab?
 The challenge framework is designed in a way that you can use any programming language. If you are not using Python or Matlab then you have to make the HTTP request to our server yourself, see Server interaction.
 Is the web server down? I receive an error message that my request is timed out.
 You can check whether the web server is up by clicking on this link. You should see a plain welcome screen. If the server is down please contact us. If the server is up please contact us with the detailed description of your problem, and the programming language and operating system you are using.
 My request has timed out. What can/should I do?
If the server is up, you can check it by clicking on this link, then the timeout might be caused by a large number of evaluations submitted at once (in a vectorized format). Since some performance functions involve (relatively) computationally demanding numerical algorithms, it can take a while to complete all the evaluations if you submit hundreds or thousands of them at once. You can either reduce the number of requested onetime evaluations and have multiple requests, or you can increase the waiting time of your local program which makes the request:
 in Python: Open evaluate.py and change the number (30 seconds) in line
r = requests.post(main_url + 'evaluate', json=body, timeout=30)
to a greater one.  in Matlab: Open evaluate.m and change the number (30 seconds) in line
options.Timeout = 30;
to a greater one.
 in Python: Open evaluate.py and change the number (30 seconds) in line
 What is the airspeed velocity of an unladen swallow?
 â€œAlthough a definitive answer would of course require further measurements, published specieswide averages of wing length and body mass, initial Strouhal estimates based on those averages and crossspecies comparisons, the Lund wind tunnel study of birds flying at a range of speeds, and revised Strouhal numbers based on that study all lead me to estimate that the average cruising airspeed velocity of an unladen European Swallow is roughly 11 meters per second, or 24 miles an hour.â€ [Corum2003]
 What is
g_val_sys
andg_val_comp
and why are they equal? g_val_sys
is the performance function value on system level andg_val_comp
contains a performance function value for each component involved in the problem. For cases with a single performance function value the component performance function is identical with the system performance function,g_val_sys=g_val_comp
. What is
alpha_sys
andalpha_comp
?  They are sensitivity values/factors: direction cosines of the vector pointing from the origin to the design point in Uspace. These sensitivity factors are often reported when FORM analysis performed and popular in standardization. For more details see section 8.1 in [Ditlevsen2007], where also
alpha
is used to denote the same variable (sensitivity factor).  What is the
user_id
for? It can be used to:
 Check your remaining number of performance function evaluations (Show budget), e.g. budget example.
 Check your submissions (Show submissions), e.g. submission example.
Change the
user_id
in the URLs to yours to see your budget and submissions. Can I contribute a reliability problem?
 Sure! We would be happy to have your contribution. You can send it via email or add it the GitLab code repository directly. After the challenge has been completed the code of the web server and all the user reliability problems will be made available in a public repository.
 Can I have access/download the probabilistic input for all reliability problems?
 Yes. You can download the probabilistic models from the GitLab repository in a tabular format by clicking on this link.
Reliability problemsÂ¶
The structural reliability benchmarking framework is an online documentation platform that contains all kind of reliability problems with their descriptions, implementation files, and visualization of the performance functions. By making this information publicly available, it is intended to stimulate a systematic and reproducible assessment of the accuracy and efficiency of currently available reliability methods and those to come in the future. Furthermore, the platform is envisaged as a dynamic environment in which you are encouraged to contribute and add new, interesting problems.
Note
For most problems the failure probabilities are calculated with numerical methods that converge to the exact solution. Due to the applied stopping criteria of these numerical methods you may attain slightly different results. The difference should be a small difference in the second decimal of the normal form (scientific notation) representation of the failure probability. The reliability index (\(\beta\)) is calculated from the failure probability (\(P_\mathrm{f}\)) the following way: \(\beta=\Phi^{1}(P_\mathrm{f})\).
RP8Â¶
Sixdimensional hyperplane.
set_id 
problem_id 

1  1 
OverviewÂ¶
Category  Value 

Type  symbolic 
Number of random variables  6 
Failure probability, \(P_\mathrm{f}\)  \(7.84\cdot10^{4}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  3.16 
Number of performance functions  1 
Reference  [Xu2018] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Lognormal  4.783  0.09975  120.0  12.0  
\(X_2\)  NA  Lognormal  4.783  0.09975  120.0  12.0  
\(X_3\)  NA  Lognormal  4.783  0.09975  120.0  12.0  
\(X_4\)  NA  Lognormal  4.783  0.09975  120.0  12.0  
\(X_5\)  NA  Lognormal  3.892  0.198  50.0  10.0  
\(X_6\)  NA  Lognormal  3.669  0.198  40.0  8.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_8
(x)[source]Â¶ Performance function for reliability problem 8.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP14Â¶
set_id 
problem_id 

1  1 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  5 
Failure probability, \(P_\mathrm{f}\)  \(7.52\cdot10^{3}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  2.42 
Number of performance functions  1 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Uniform  70.0  80.0  75.0  2.887  
\(X_2\)  NA  Normal  39.0  0.1  39.0  0.1  
\(X_3\)  NA  Gumbelmax  1342.0  272.9  1500.0  350.0  
\(X_4\)  NA  Normal  400.0  0.1  400.0  0.1  
\(X_5\)  NA  Normal  250000.0  35000.0  250000.0  35000.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_14
(x)[source]Â¶ Performance function for reliability problem 14.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP22Â¶
Quadratic function with mixed term, convex.
set_id 
problem_id 

1  2 
OverviewÂ¶
Category  Value 

Type  symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(4.16\cdot10^{3}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  2.64 
Number of performance functions  1 
Reference  [Grooteman2011] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_2\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_22
(x)[source]Â¶ Performance function for reliability problem 22.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP24Â¶
set_id 
problem_id 

1  2 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(2.86\cdot10^{3}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  2.76 
Number of performance functions  1 
Reference  [Dai2016] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  10.0  3.0  10.0  3.0  
\(X_2\)  NA  Normal  10.0  3.0  10.0  3.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_24
(x)[source]Â¶ Performance function for reliability problem 22.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP25Â¶
set_id 
problem_id 

2  1 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(6.14\cdot10^{6}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  4.36 
Number of performance functions  2 
Reference  [Dai2016] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_{2}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_111
(x)[source]Â¶ Performance function for reliability problem 111.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP28Â¶
set_id 
problem_id 

1  3 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(1.46\cdot10^{7}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  5.11 
Number of performance functions  1 
Reference  [Dai2016] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  78064.0  11710.0  78064.0  11710.0  
\(X_2\)  NA  Normal  0.0104  0.00156  0.0104  0.00156 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_28
(x)[source]Â¶ Performance function for reliability problem 28.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP31Â¶
set_id 
problem_id 

1  4 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(1.80\cdot10^{4}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  3.58 
Number of performance functions  1 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_2\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_31
(x)[source]Â¶ Performance function for reliability problem 31.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP33Â¶
set_id 
problem_id 

1  3 
2  2 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  3 
Failure probability, \(P_\mathrm{f}\)  \(2.57\cdot10^{3}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  2.80 
Number of performance functions  2 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_{2}\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_{3}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶

gfun_33
(x)[source]Â¶ Performance function for reliability problem 33.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP35Â¶
set_id 
problem_id 

2  3 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(3.54\cdot10^{3}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  2.70 
Number of performance functions  2 
Reference  [Dai2016] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_{2}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶

gfun_35
(x)[source]Â¶ Performance function for reliability problem 35.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP38Â¶
set_id 
problem_id 

1  5 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  7 
Failure probability, \(P_\mathrm{f}\)  \(8.10\cdot10^{3}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  2.48 
Number of performance functions  1 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  350.0  35.0  350.0  35.0  
\(X_2\)  NA  Normal  50.8  5.08  50.8  5.08  
\(X_3\)  NA  Normal  3.81  0.381  3.81  0.381  
\(X_4\)  NA  Normal  173.0  17.3  173.0  17.3  
\(X_5\)  NA  Normal  9.38  0.938  9.38  0.938  
\(X_6\)  NA  Normal  33.1  3.31  33.1  3.31  
\(X_7\)  NA  Normal  0.036  0.0036  0.036  0.0036 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶

gfun_38
(x)[source]Â¶ Performance function for reliability problem 38.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP53Â¶
set_id 
problem_id 

1  6 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(3.13\cdot10^{2}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  1.86 
Number of performance functions  1 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  1.5  1.0  1.5  1.0  
\(X_2\)  NA  Normal  2.5  1.0  2.5  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_53
(x)[source]Â¶ Performance function for reliability problem 53.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP54Â¶
set_id 
problem_id 

1  7 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  20 
Failure probability, \(P_\mathrm{f}\)  \(9.98\cdot10^{4}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  3.09 
Number of performance functions  1 
Reference  [Dai2016] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Exponential  1.0  1.0  1.0  
\(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\) 
\(X_{20}\)  NA  Exponential  1.0  1.0  1.0 
The random variables are identically distributed and mutually independent.
VisualizationÂ¶
ImplementationÂ¶

gfun_54
(x)[source]Â¶ Performance function for reliability problem 54.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP55Â¶
set_id 
problem_id 

2  4 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(3.60\cdot10^{1}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  0.15 
Number of performance functions  4 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Uniform  1.0  1.0  0.0  0.5774  
\(X_{2}\)  NA  Uniform  1.0  1.0  0.0  0.5774 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_55
(x)[source]Â¶ Performance function for reliability problem 55.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP57Â¶
set_id 
problem_id 

2  5 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(2.84\cdot10^{2}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  1.91 
Number of performance functions  3 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_{2}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_57
(x)[source]Â¶ Performance function for reliability problem 57.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP60Â¶
set_id 
problem_id 

2  6 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  5 
Failure probability, \(P_\mathrm{f}\)  \(4.56\cdot10^{2}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  1.70 
Number of performance functions  7 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Lognormal  7.691  0.09975  2200.0  220.0  
\(X_{2}\)  NA  Lognormal  7.645  0.09975  2100.0  210.0  
\(X_{3}\)  NA  Lognormal  7.736  0.09975  2300.0  230.0  
\(X_{4}\)  NA  Lognormal  7.596  0.09975  2000.0  200.0  
\(X_{5}\)  NA  Lognormal  7.016  0.3853  1200.0  480.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_60
(x)[source]Â¶ Performance function for reliability problem 60.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP63Â¶
set_id 
problem_id 

1  8 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  100 
Failure probability, \(P_\mathrm{f}\)  \(3.79\cdot10^{4}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  3.36 
Number of performance functions  1 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  0.0  1.0  0.0  1.0  
\(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\) 
\(X_{100}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_63
(x)[source]Â¶ Performance function for reliability problem 63.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP75Â¶
set_id 
problem_id 

1  9 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(1.07\cdot10^{2}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  2.33 
Number of performance functions  1 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_2\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_75
(x)[source]Â¶ Performance function for reliability problem 75.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP77Â¶
set_id 
problem_id 

2  7 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  3 
Failure probability, \(P_\mathrm{f}\)  \(2.87\cdot10^{7}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  5.00 
Number of performance functions  2 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Normal  10.0  0.5  10.0  0.5  
\(X_{2}\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_{3}\)  NA  Normal  4.0  1.0  4.0  1.0 
The random variables are mutually independent.
ImplementationÂ¶

gfun_77
(x)[source]Â¶ Performance function for reliability problem 77.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP89Â¶
set_id 
problem_id 

2  8 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(5.43\cdot10^{3}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  2.55 
Number of performance functions  2 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_{2}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_89
(x)[source]Â¶ Performance function for reliability problem 89.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP91Â¶
set_id 
problem_id 

2  9 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  5 
Failure probability, \(P_\mathrm{f}\)  \(6.97\cdot10^{4}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  3.19 
Number of performance functions  3 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Normal  0.07433  0.005  0.07433  0.005  
\(X_{2}\)  NA  Normal  0.1  0.01  0.1  0.01  
\(X_{3}\)  NA  Normal  13.0  60.0  13.0  60.0  
\(X_{4}\)  NA  Normal  4751.0  48.0  4751.0  48.0  
\(X_{5}\)  NA  Normal  684.0  11.0  684.0  11.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_91
(x)[source]Â¶ Performance function for reliability problem 91.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP107Â¶
set_id 
problem_id 

1  10 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  10 
Failure probability, \(P_\mathrm{f}\)  \(2.92\cdot10^{7}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  5.0 
Number of performance functions  1 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  0.0  1.0  0.0  1.0  
\(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\) 
\(X_{10}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are identically distributed and mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_107
(x)[source]Â¶ Performance function for reliability problem 107.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP110Â¶
set_id 
problem_id 

2  10 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(3.19\cdot10^{5}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  4.00 
Number of performance functions  2 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_{2}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_110
(x)[source]Â¶ Performance function for reliability problem 25.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP111Â¶
set_id 
problem_id 

1  11 
OverviewÂ¶
Category  Value 

Type  Symbolic 
Number of random variables  2 
Failure probability, \(P_\mathrm{f}\)  \(7.65\cdot10^{7}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  4.81 
Number of performance functions  1 
Reference  [Schueller2004] 
Performance functionÂ¶
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_2\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_111
(x)[source] Performance function for reliability problem 111.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP201Â¶
set_id 
problem_id 

1  12 
OverviewÂ¶
Category  Value 

Type  Numerical (finite element analysis) 
Number of random variables  21 
Failure probability, \(P_\mathrm{f}\)  \(1.05\cdot10^{4}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  3.7 
Number of performance functions  1 
Reference  [Blatman2010] 
Performance functionÂ¶
Too complex to be written here, see the implementation in the code repository.
Random variablesÂ¶
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  0.0  1.0  0.0  1.0  
\(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\) 
\(X_{21}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_201
(x)[source]Â¶ Performance function for reliability problem 201.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP202Â¶
set_id 
problem_id 

2  11 
OverviewÂ¶
Category  Value 

Type  Numerical (finite element analysis) 
Number of random variables  225 
Failure probability, \(P_\mathrm{f}\)  \(6.03\cdot10^{5}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  3.43 
Number of performance functions  2 
Reference  [Schueller2007] 
Performance functionÂ¶
Too complex to be written here, see the implementation in the code repository.
Random variablesÂ¶
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  0.0  1.0  0.0  1.0  
\(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\) 
\(X_{225}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_202
(x)[source]Â¶ Performance function for reliability problem 202.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP203Â¶
set_id 
problem_id 

1  13 
OverviewÂ¶
Category  Value 

Type  Numerical (finite element analysis surrogate) 
Number of random variables  4 
Failure probability, \(P_\mathrm{f}\)  \(4.33\cdot10^{7}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  4.92 
Number of performance functions  1 
Reference  [Eijnden2019] 
Performance functionÂ¶
Too complex to be written here, see the implementation in the code repository.
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_{2}\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_{3}\)  NA  Normal  0.0  1.0  0.0  1.0  
\(X_{4}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_203
(x)[source]Â¶ Performance function for reliability problem 203. Bramâ€™s geotechnical problem.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP213Â¶
set_id 
problem_id 

1  14 
OverviewÂ¶
Category  Value 

Type  Numeric (finite element analysis) 
Number of random variables  13 
Failure probability, \(P_\mathrm{f}\)  \(2.84\cdot10^{4}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  3.45 
Number of performance functions  1 
Reference  [Blatman2010] 
Performance functionÂ¶
Too complex to be written here, see the implementation in the code repository.
Random variablesÂ¶
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  NA  Normal  0.0  1.0  0.0  1.0  
\(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\) 
\(X_{13}\)  NA  Normal  0.0  1.0  0.0  1.0 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_213_le_frame
(x)[source]Â¶ Performance function for reliability problem 213.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP300Â¶
set_id 
problem_id 

1  15 
OverviewÂ¶
Category  Value 

Type  Numerical 
Number of random variables  14 
Failure probability, \(P_\mathrm{f}\)  \(5.22\cdot10^{5}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  3.88 
Number of performance functions  1 
Reference  [Sepulveda2019] 
Performance functionÂ¶
Too complex to be written here, see the implementation in the code repository.
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_1\)  DACC  Normal  0  1  
\(X_2\)  DACC  Normal  0  1  
\(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  \(\vdots\)  
\(X_{14}\)  DACC  Normal  0  1 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_300
(x)[source]Â¶ Performance function for reliability problem 300.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
RP301Â¶
set_id 
problem_id 

1  16 
OverviewÂ¶
Category  Value 

Type  Numerical (finite element analysis surrogate) 
Number of random variables  12 
Failure probability, \(P_\mathrm{f}\)  \(6.9\cdot10^{5}\) 
Reliability index, \(\beta=\Phi^{1}(P_\mathrm{f})\)  3.81 
Number of performance functions  1 
Reference  [Slobbe2019] 
Performance functionÂ¶
Too complex to be written here, see the implementation in the code repository.
Random variablesÂ¶
The parametrization of distributions follows that of in Distributions.
Variable  Description  Distribution  \(\theta_1\)  \(\theta_2\)  \(\theta_3\)  \(\theta_4\)  Mean  Std 

\(X_{1}\)  NA  Lognormal  4.476  0.05677  88.0  5.0  
\(X_{2}\)  NA  Lognormal  6.084  0.0681  440.0  30.0  
\(X_{3}\)  NA  Lognormal  6.18  0.0681  484.0  33.0  
\(X_{4}\)  NA  Lognormal  2.663  0.08982  0.07  0.0063  
\(X_{5}\)  NA  Lognormal  6.378  0.06941  590.0  41.0  
\(X_{6}\)  NA  Lognormal  6.473  0.06925  649.0  45.0  
\(X_{7}\)  NA  Lognormal  2.663  0.08982  0.07  0.0063  
\(X_{8}\)  NA  Normal  590.0  59.0  590.0  59.0  
\(X_{9}\)  NA  Gumbelmax  268.4  46.0  295.0  59.0  
\(X_{10}\)  NA  Lognormal  0.03797  0.04997  1.04  0.052  
\(X_{11}\)  NA  Lognormal  0.004975  0.09975  1.0  0.1  
\(X_{12}\)  NA  Lognormal  0.004975  0.09975  1.0  0.1 
The random variables are mutually independent.
VisualizationÂ¶
ImplementationÂ¶
PythonÂ¶

gfun_301
(x)[source]Â¶ Performance function for reliability problem 301. High strength RC deep beam.
Parameters: x (numpy.array of float(s)) â€“ Values of independent variables: columns are the different parameters/random variables (x1, x2,â€¦xn) and rows are different parameter/random variables sets for different calls. Returns:  g_val_sys (numpy.array of float(s)) â€“ Performance function value for the system.
 g_val_comp (numpy.array of float(s)) â€“ Performance function value for each component.
 msg (str) â€“ Accompanying diagnostic message, e.g. warning.
DistributionsÂ¶
 Continuous:
NormalÂ¶
ParametrizationÂ¶
Category  Value 

Type  univariate, continuous 
Support  \(x \in (\infty,\infty)\) 
Parameter  \(\theta_1 = \mu \in (\infty,\infty)\), location 
\(\theta_2 = \sigma \in (0,\infty)\), scale  
Mean  \(\mu\) 
Variance  \(\sigma^2\) 
LognormalÂ¶
ParametrizationÂ¶
Category  Value 

Type  univariate, continuous 
Support  \(x \in (0,\infty)\) 
Parameter  \(\theta_1 = \mu \in (\infty,\infty)\), shape 
\(\theta_2 = \sigma \in (0,\infty)\), scale  
Mean  \({e^{\left( {\mu + \frac{{{\sigma ^2}}}{2}} \right)}}\) 
Variance  \(\left( {{e^{{\sigma ^2}}}  1} \right) \cdot {e^{2\mu + {\sigma ^2}}}\) 
GumbelmaxÂ¶
ParametrizationÂ¶
Category  Value 

Type  univariate, continuous 
Support  \(x \in (\infty,\infty)\) 
Parameter  \(\theta_1 = \mu \in (\infty,\infty)\), location 
\(\theta_2 = \beta \in (0,\infty)\), scale  
Mean  \(\mu + \beta \cdot 0.5772\)[*] 
Variance  \(\frac{{{\pi ^2}}}{6} \cdot {\beta ^2}\) 
[*]  EulerMascheroni constant. 
GammaÂ¶
ParametrizationÂ¶
Category  Value 

Type  univariate, continuous 
Support  \(x \in (0,\infty )\) 
Parameter  \(\theta_1 = k \in (0,\infty )\), shape 
\(\theta_2 = \theta \in (0,\infty )\), scale  
Mean  \(k \cdot \theta\) 
Variance  \(k \cdot \theta^2\) 
Probability density functionÂ¶
Where \(\Gamma(.)\) is the gamma function.
Cumulative distribution functionÂ¶
Where \(\gamma(.)\) is the lower incomplete gamma function.
UniformÂ¶
ParametrizationÂ¶
Category  Value 

Type  univariate, continuous 
Support  \(x \in [a,b]\) 
Parameter  \(\theta_1 = a \in (\infty,b)\), lower bound 
\(\theta_2 = b \in (a,\infty)\), upper bound  
Mean  \({\tfrac {1}{2}} \cdot (a+b)\) 
Variance  \({\tfrac {1}{12}} \cdot (ba)^{2}\) 
Truncated NormalÂ¶
ParametrizationÂ¶
Category  Value 

Type  univariate, continuous 
Support  \(x \in [a,b]\) 
Parameter  \(\theta_1 = \mu \in (\infty,\infty)\), location 
\(\theta_2 = \sigma \in (0,\infty)\), scale [â€ ]  
\(\theta_3 = a \in (\infty,b)\), lower bound  
\(\theta_4 = b \in (a,\infty)\), upper bound  
Mean  \(\mu +{\frac {\phi (\alpha )\phi (\beta )}{Z}} \cdot \sigma\) 
Variance  \({\sigma ^2} \cdot \left[ {1 + \frac{{\alpha \cdot \phi (\alpha )  \beta \cdot \phi (\beta )}}{Z}  {{\left( {\frac{{\phi (\alpha )  \phi (\beta )}}{Z}} \right)}^2}} \right]\) 
[â€ ]  For a more rigorous definition see the Wikipedia page of the truncated normal distribution. 
Probability density functionÂ¶
Where the auxiliary variables are defines as:
and \(\phi(.)\) and \(\Phi(.)\) are the standard normal probability density function (Eq. (24)) and cumulative distribution function (Eq. (25)), respectively.