#include <boost/math/distributions/hyperexponential.hpp>

namespace boost{ namespace math{
template <typename RealType = double,
          typename Policy   = policies::policy<> >
class hyperexponential_distribution;
typedef hyperexponential_distribution<> hyperexponential;
template <typename RealType, typename Policy>
class hyperexponential_distribution
{
public:
   typedef RealType value_type;
   typedef Policy   policy_type;
   // Constructors:
   hyperexponential_distribution();  // Default.
   template <typename RateIterT, typename RateIterT2>
   hyperexponential_distribution(  // Default equal probabilities.
                                 RateIterT const& rate_first,
                                 RateIterT2 const& rate_last);  // Rates using Iterators.
   template <typename ProbIterT, typename RateIterT>
   hyperexponential_distribution(ProbIterT prob_first, ProbIterT prob_last,
                                 RateIterT rate_first, RateIterT rate_last);   // Iterators.
   template <typename ProbRangeT, typename RateRangeT>
   hyperexponential_distribution(ProbRangeT const& prob_range,
                                 RateRangeT const& rate_range);  // Ranges.
   template <typename RateRangeT>
   hyperexponential_distribution(RateRangeT const& rate_range);
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)     // C++11 initializer lists supported.
   hyperexponential_distribution(std::initializer_list<RealType> l1, std::initializer_list<RealType> l2);
   hyperexponential_distribution(std::initializer_list<RealType> l1);
 #endif
   // Accessors:
   std::size_t num_phases() const;
   std::vector<RealType> probabilities() const;
   std::vector<RealType> rates() const;
};
}} // namespaces

	Note
	Предусмотрен механизм реализации, позволяющий избежать двусмысленности между конструкторами, принимающими в качестве параметров диапазоны, итераторы и константы. Это должно быть прозрачно для пользователя. См. ниже и файл заголовка hyperexponential.hpp для деталей и пояснительных комментариев.

Тип класса<hyperexponential_distribution>представляет собойгиперэкспоненциальное распределение.

Ak-фазовое гиперэкспоненциальное распределение - этонепрерывное распределение вероятностей, полученное в виде смесиkЭкспоненциальное распределениес. Его также называютсмешанным экспоненциальным распределениемили параллельным.k-фаза экспоненциального распределения.

Ak-фаза гиперэкспоненциального распределения характеризуется двумя параметрами, а именно aфазовый вероятностный вектор& #945;= [α₁, ..., & #945;_k]ивектор скорости& #955;= [λ₁, ..., & #955;_k].

Функцияплотности вероятностидля случайной вариацииxв гиперэкспоненциальном распределении задается:

Следующий график иллюстрирует PDF гиперэкспоненциального распределения с пятью различными параметрами, а именно:

Кроме того, следующий график иллюстрирует PDF гиперэкспоненциального распределения (твердые линии), где толькофазовый вектор вероятностиизменяется вместе с PDF двух ограничивающих экспоненциальных распределений (разбросанных линий):

Как и ожидалось, в качестве первого элемента& #945;₁фазовый вектор вероятностиприближается к(или, эквивалентно,и #945;₂0), получающееся гиперэкспоненциальное распределение приближается к экспоненциальному распределению с параметром& #955;=0,5. И наоборот, как первый элемент& #945;₂фазовый вектор вероятностиприближается к(или, эквивалентно,и #945;₁0), получающееся гиперэкспоненциальное распределение приближается к экспоненциальному распределению с параметром& #955;=1,5.

Наконец, следующий график сравнивает PDF гиперэкспоненциального распределения с различным числом фаз, но с тем же средним значением, равным2:

Как можно отметить, даже если три распределения имеют одинаковое среднее значение, два гиперэкспоненциальных распределения имеют хвостпо отношению к одному из экспоненциального распределения. Действительно, гиперэкспоненциальное распределение имеет большую изменчивость, чем экспоненциальное распределение, что приводит ккоэффициенту вариациибольше, чем1(в отличие от одного из экспоненциального распределения, которое точно1).

Applications

Ak-фазовое гиперэкспоненциальное распределение часто используется втеории очередейдля моделирования распределения суперпозицииkнезависимых событий, таких как, например, распределение времени обслуживания очередей станции сkсерверов параллельно, гдеi--й сервер выбран с вероятностью& #945;_iи его распределение времени обслуживания является экспоненциальным распределением со скоростью& #955;_i(Allen, 1990; Papadopolous et al., 1993; Trivedi, 2002).

Например, часто наблюдалось, что распределение рабочего времени процессоров в вычислительной системе обладает таким распределением (Rosin, 1965). Кроме того, прибытие различных типов клиентов на одну станцию очереди часто моделируется как гиперэкспоненциальное распределение (Papadopolous et al., 1993). Аналогичным образом, если продукт, изготовленный на нескольких параллельных сборочных линиях, и выходы объединены, плотность отказов общего продукта, вероятно, будет гиперэкспоненциальной (Trivedi,2002).

Наконец, поскольку гиперэкспоненциальное распределение демонстрирует высокий коэффициент вариации (CoV), то есть CoV >1, оно особенно подходит для соответствия эмпирическим данным с большим CoV (Feitelson, 2014; Wolski et al., 2013) и для приближенияраспределений вероятности с длинным хвостом(Feldmann et al., 1998).

Related distributions

Examples

Lifetime of Appliances

Предположим, клиент покупает прибор и выбирает случайным образом между прибором со средним сроком службы 10 лет и прибором со средним сроком службы 12 лет. Предполагая, что срок службы этого устройства следует за экспоненциальным распределением, распределение срока службы приобретенного устройства может быть смоделировано как гиперэкспоненциальное распределение с вектором фазовой вероятности& #945;= (1/2,1/2)и вектором скорости& #955;= (1/10,1/12)(Wolfram, 2014).

В остальной части этого раздела мы приводим пример реализации C++ для расчета среднего срока службы и вероятности того, что устройство будет работать более 15 лет.

#include <boost/math/distributions/hyperexponential.hpp>
#include <iostream>
int main()
{
   const double rates[] = { 1.0 / 10.0, 1.0 / 12.0 };
   boost::math::hyperexponential he(rates);
   std::cout << "Average lifetime: "
      << boost::math::mean(he)
      << " years" << std::endl;
   std::cout << "Probability that the appliance will work for more than 15 years: "
      << boost::math::cdf(boost::math::complement(he, 15.0))
      << std::endl;
}

Результатом является:

Average lifetime: 11 years
Probability that the appliance will work for more than 15 years: 0.254817

Workloads of Private Cloud Computing Systems

Облачные вычислениястали популярной метафорой для динамического и безопасного доступа к вычислительным возможностям и возможностям хранения. В работе (Wolski et al., 2013) авторы анализируют и моделируют рабочие нагрузки, собранные из управляемых предприятием коммерческихчастных облаков, и показывают, что 3-фазные гиперэкспоненциальные распределения (с использованием алгоритмаожидаемой максимизации) точно фиксируют атрибуты рабочей нагрузки.

В этом типе вычислительной системы запросы пользователей состоят в требовании предоставления одной или несколькихвиртуальных машин(VM). В частности, в (Wolski et al., 2013) рабочая нагрузка, испытываемая каждой облачной системой, является функцией четырех распределений, по одному для каждого из следующих атрибутов рабочей нагрузки:

Авторы предполагают, что все виртуальные машины в запросе имеют одинаковое количество ядер, но размеры запросов и количество ядер могут варьироваться от запроса к запросу. Кроме того, предполагается, что все виртуальные машины в рамках запроса имеют одинаковый срок службы. Учитывая эти предположения, авторы строят статистическую модель для атрибутов межприбыльного времени запроса и времени жизни виртуальной машины, укладывая свои соответствующие данные в 3-фазное гиперэкспоненциальное распределение.

В следующей таблице мы показываем среднее значение выборки и стандартное отклонение (SD) в секундах запроса межприбыльного времени и распределения времени жизни VM трех наборов данных, собранных авторами:

Принимая во внимание, что в следующей таблице мы показываем гиперэкспоненциальные параметры распределения в результате соответствия:

В остальной части этого раздела мы приводим пример реализации C++ для вычисления некоторых статистических свойств установленных дистрибутивов для каждого из анализируемых наборов данных.

#include <boost/math/distributions.hpp>
#include <iostream>
#include <string>
struct ds_info
{
   std::string name;
   double iat_sample_mean;
   double iat_sample_sd;
   boost::math::hyperexponential iat_he;
   double multi_lt_sample_mean;
   double multi_lt_sample_sd;
   boost::math::hyperexponential multi_lt_he;
   double single_lt_sample_mean;
   double single_lt_sample_sd;
   boost::math::hyperexponential single_lt_he;
};
// DS1 dataset
ds_info make_ds1()
{
   ds_info ds;
   ds.name = "DS1";
   // VM interarrival time distribution
   const double iat_fit_probs[] = { 0.34561,0.08648,0.56791 };
   const double iat_fit_rates[] = { 0.0008,0.00005,0.02894 };
   ds.iat_sample_mean = 2202.1;
   ds.iat_sample_sd = 2.2e+4;
   ds.iat_he = boost::math::hyperexponential(iat_fit_probs, iat_fit_rates);
   // Multi-core VM lifetime distribution
   const double multi_lt_fit_probs[] = { 0.24667,0.37948,0.37385 };
   const double multi_lt_fit_rates[] = { 0.00004,0.000002,0.00059 };
   ds.multi_lt_sample_mean = 257173;
   ds.multi_lt_sample_sd = 4.6e+5;
   ds.multi_lt_he = boost::math::hyperexponential(multi_lt_fit_probs, multi_lt_fit_rates);
   // Single-core VM lifetime distribution
   const double single_lt_fit_probs[] = { 0.09325,0.22251,0.68424 };
   const double single_lt_fit_rates[] = { 0.000003,0.00109,0.00109 };
   ds.single_lt_sample_mean = 28754.4;
   ds.single_lt_sample_sd = 1.6e+5;
   ds.single_lt_he = boost::math::hyperexponential(single_lt_fit_probs, single_lt_fit_rates);
   return ds;
}
// DS2 dataset
ds_info make_ds2()
{
   ds_info ds;
   ds.name = "DS2";
   // VM interarrival time distribution
   const double iat_fit_probs[] = { 0.38881,0.18227,0.42892 };
   const double iat_fit_rates[] = { 0.000006,0.05228,0.00081 };
   ds.iat_sample_mean = 41285.7;
   ds.iat_sample_sd = 1.1e+05;
   ds.iat_he = boost::math::hyperexponential(iat_fit_probs, iat_fit_rates);
   // Multi-core VM lifetime distribution
   const double multi_lt_fit_probs[] = { 0.42093,0.43960,0.13947 };
   const double multi_lt_fit_rates[] = { 0.00186,0.00008,0.0000008 };
   ds.multi_lt_sample_mean = 144669.0;
   ds.multi_lt_sample_sd = 7.9e+05;
   ds.multi_lt_he = boost::math::hyperexponential(multi_lt_fit_probs, multi_lt_fit_rates);
   // Single-core VM lifetime distribution
   const double single_lt_fit_probs[] = { 0.44885,0.30675,0.2444 };
   const double single_lt_fit_rates[] = { 0.00143,0.00005,0.0000004 };
   ds.single_lt_sample_mean = 599815.0;
   ds.single_lt_sample_sd = 1.7e+06;
   ds.single_lt_he = boost::math::hyperexponential(single_lt_fit_probs, single_lt_fit_rates);
   return ds;
}
// DS3 dataset
ds_info make_ds3()
{
   ds_info ds;
   ds.name = "DS3";
   // VM interarrival time distribution
   const double iat_fit_probs[] = { 0.39442,0.24644,0.35914 };
   const double iat_fit_rates[] = { 0.00030,0.00003,0.00257 };
   ds.iat_sample_mean = 11238.8;
   ds.iat_sample_sd = 3.0e+04;
   ds.iat_he = boost::math::hyperexponential(iat_fit_probs, iat_fit_rates);
   // Multi-core VM lifetime distribution
   const double multi_lt_fit_probs[] = { 0.37621,0.14838,0.47541 };
   const double multi_lt_fit_rates[] = { 0.00498,0.000005,0.00022 };
   ds.multi_lt_sample_mean = 30739.2;
   ds.multi_lt_sample_sd = 1.6e+05;
   ds.multi_lt_he = boost::math::hyperexponential(multi_lt_fit_probs, multi_lt_fit_rates);
   // Single-core VM lifetime distribution
   const double single_lt_fit_probs[] = { 0.34131,0.12544,0.53325 };
   const double single_lt_fit_rates[] = { 0.000297,0.000003,0.00410 };
   ds.single_lt_sample_mean = 44447.8;
   ds.single_lt_sample_sd = 2.2e+05;
   ds.single_lt_he = boost::math::hyperexponential(single_lt_fit_probs, single_lt_fit_rates);
   return ds;
}
void print_fitted(ds_info const& ds)
{
   const double secs_in_a_hour = 3600;
   const double secs_in_a_month = 30 * 24 * secs_in_a_hour;
   std::cout << "### " << ds.name << std::endl;
   std::cout << "* Fitted Request Interarrival Time" << std::endl;
   std::cout << " - Mean (SD): " << boost::math::mean(ds.iat_he) << " (" << boost::math::standard_deviation(ds.iat_he) << ") seconds." << std::endl;
   std::cout << " - 99th Percentile: " << boost::math::quantile(ds.iat_he, 0.99) << " seconds." << std::endl;
   std::cout << " - Probability that a VM will arrive within 30 minutes: " << boost::math::cdf(ds.iat_he, secs_in_a_hour / 2.0) << std::endl;
   std::cout << " - Probability that a VM will arrive after 1 hour: " << boost::math::cdf(boost::math::complement(ds.iat_he, secs_in_a_hour)) << std::endl;
   std::cout << "* Fitted Multi-core VM Lifetime" << std::endl;
   std::cout << " - Mean (SD): " << boost::math::mean(ds.multi_lt_he) << " (" << boost::math::standard_deviation(ds.multi_lt_he) << ") seconds." << std::endl;
   std::cout << " - 99th Percentile: " << boost::math::quantile(ds.multi_lt_he, 0.99) << " seconds." << std::endl;
   std::cout << " - Probability that a VM will last for less than 1 month: " << boost::math::cdf(ds.multi_lt_he, secs_in_a_month) << std::endl;
   std::cout << " - Probability that a VM will last for more than 3 months: " << boost::math::cdf(boost::math::complement(ds.multi_lt_he, 3.0*secs_in_a_month)) << std::endl;
   std::cout << "* Fitted Single-core VM Lifetime" << std::endl;
   std::cout << " - Mean (SD): " << boost::math::mean(ds.single_lt_he) << " (" << boost::math::standard_deviation(ds.single_lt_he) << ") seconds." << std::endl;
   std::cout << " - 99th Percentile: " << boost::math::quantile(ds.single_lt_he, 0.99) << " seconds." << std::endl;
   std::cout << " - Probability that a VM will last for less than 1 month: " << boost::math::cdf(ds.single_lt_he, secs_in_a_month) << std::endl;
   std::cout << " - Probability that a VM will last for more than 3 months: " << boost::math::cdf(boost::math::complement(ds.single_lt_he, 3.0*secs_in_a_month)) << std::endl;
}
int main()
{
   print_fitted(make_ds1());
   print_fitted(make_ds2());
   print_fitted(make_ds3());
}

Полученный выход (с точностью плавающей точки, установленной на 2) является:

### DS1
* Fitted Request Interarrival Time
 - Mean (SD): 2.2e+03 (8.1e+03) seconds.
 - 99th Percentile: 4.3e+04 seconds.
 - Probability that a VM will arrive within 30 minutes: 0.84
 - Probability that a VM will arrive after 1 hour: 0.092
* Fitted Multi-core VM Lifetime
 - Mean (SD): 2e+05 (3.9e+05) seconds.
 - 99th Percentile: 1.8e+06 seconds.
 - Probability that a VM will last for less than 1 month: 1
 - Probability that a VM will last for more than 3 months: 6.7e-08
* Fitted Single-core VM Lifetime
 - Mean (SD): 3.2e+04 (1.4e+05) seconds.
 - 99th Percentile: 7.4e+05 seconds.
 - Probability that a VM will last for less than 1 month: 1
 - Probability that a VM will last for more than 3 months: 6.9e-12
### DS2
* Fitted Request Interarrival Time
 - Mean (SD): 6.5e+04 (1.3e+05) seconds.
 - 99th Percentile: 6.1e+05 seconds.
 - Probability that a VM will arrive within 30 minutes: 0.52
 - Probability that a VM will arrive after 1 hour: 0.4
* Fitted Multi-core VM Lifetime
 - Mean (SD): 1.8e+05 (6.4e+05) seconds.
 - 99th Percentile: 3.3e+06 seconds.
 - Probability that a VM will last for less than 1 month: 0.98
 - Probability that a VM will last for more than 3 months: 0.00028
* Fitted Single-core VM Lifetime
 - Mean (SD): 6.2e+05 (1.6e+06) seconds.
 - 99th Percentile: 8e+06 seconds.
 - Probability that a VM will last for less than 1 month: 0.91
 - Probability that a VM will last for more than 3 months: 0.011
### DS3
* Fitted Request Interarrival Time
 - Mean (SD): 9.7e+03 (2.2e+04) seconds.
 - 99th Percentile: 1.1e+05 seconds.
 - Probability that a VM will arrive within 30 minutes: 0.53
 - Probability that a VM will arrive after 1 hour: 0.36
* Fitted Multi-core VM Lifetime
 - Mean (SD): 3.2e+04 (1e+05) seconds.
 - 99th Percentile: 5.4e+05 seconds.
 - Probability that a VM will last for less than 1 month: 1
 - Probability that a VM will last for more than 3 months: 1.9e-18
* Fitted Single-core VM Lifetime
 - Mean (SD): 4.3e+04 (1.6e+05) seconds.
 - 99th Percentile: 8.4e+05 seconds.
 - Probability that a VM will last for less than 1 month: 1
 - Probability that a VM will last for more than 3 months: 9.3e-12

	Note
	Приведенные выше результаты отличаются от результатов, показанных в таблицах III, V и VII (Wolski et al., 2013). Мы тщательно проверили их с помощью Wolfram Mathematica 10, что подтвердило наши результаты.

Member Functions

Default Constructor

hyperexponential_distribution();

Построение a1-фазного гиперэкспоненциального распределения (т.е. экспоненциального распределения) со скоростью<1>.

Constructor from Iterators

template <typename ProbIterT, typename RateIterT>
hyperexponential_distribution(ProbIterT prob_first, ProbIterT prob_last,
                              RateIterT rate_first, RateIterT rate_last);

Построение гиперэкспоненциального распределения сфазовым вектором вероятностипараметром, заданным диапазоном, определенным парой итераторов<prob_first>,<prob_last>ивектором скоростипараметром, заданным диапазоном, заданным парой итераторов<rate_first>,<rate_last>.

Parameters

Type Requirements

Example

std::array<double, 2> phase_prob = { 0.5, 0.5 };
std::array<double, 2> rates = { 1.0 / 10, 1.0 / 12 };
hyperexponential he(phase_prob.begin(), phase_prob.end(), rates.begin(), rates.end());

Construction from Ranges/Containers

template <typename ProbRangeT, typename RateRangeT>
hyperexponential_distribution(ProbRangeT const& prob_range,
                              RateRangeT const& rate_range);

Построение гиперэкспоненциального распределения сфазовым вектором вероятностипараметром, заданным диапазоном, определенным<prob_range>, ивектором скоростипараметром, заданным диапазоном, заданным<rate_range>.

	Note
	В качестве детали реализации этот конструктор использует механизмBoost's enable_if/disable_ifдля разграничения между этим и другими конструкторами 2-аргументов. Обратитесь к исходному коду для более подробной информации.

Parameters

Type Requirements

Examples

// We could be using any standard library container here... vector, deque, array, list etc:
std::array<double, 2> phase_prob = { 0.5, 0.5 };
std::array<double, 2> rates      = { 1.0 / 10, 1.0 / 12 };
hyperexponential he1(phase_prob, rates);    // Construct from standard library container.
double phase_probs2[] = { 0.5, 0.5 };
double rates2[]       = { 1.0 / 10, 1.0 / 12 };
hyperexponential he2(phase_probs2, rates2);  // Construct from native C++ array.

Construction with rates-iterators (and all phase probabilities equal)

template <typename RateIterT, typename RateIterT2>
hyperexponential_distribution(RateIterT const& rate_first,
                              RateIterT2 const& rate_last);

Конструирует гиперэкспоненциальное распределение свектором скоростипараметром, заданным диапазоном, определенным парой итераторов<rate_first>,<rate_last>ивектором вероятности фазы, установленным на равные фазовые вероятности (т.е. на вектор одинаковой длины<n>вектора скоростии с каждым элементом, установленным на<1.0/n>).

	Note
	В качестве детали реализации этот конструктор использует механизмBoost's enable_if/disable_ifдля разграничения между этим и другими конструкторами 2-аргументов. Обратитесь к исходному коду для более подробной информации.

Parameters

Type Requirements

Example

// We could be using any standard library container here... vector, deque, array, list etc:
std::array<double, 2> rates = { 1.0 / 10, 1.0 / 12 };
hyperexponential he(rates.begin(), rates.end());
assert(he.probabilities()[0] == 0.5); // Phase probabilities will be equal and normalised to unity.

Construction from a single range of rates (all phase probabilities will be equal)

template <typename RateRangeT>
hyperexponential_distribution(RateRangeT const& rate_range);

Построено гиперэкспоненциальное распределение свектором скоростипараметром, заданным диапазоном, определенным<rate_range>, ивектором вероятности фазы, установленным на равные фазовые вероятности (т.е. на вектор одинаковой длины<n>вектора скоростии с каждым элементом, установленным на<1.0/n>).

Parameters

Type Requirements

Examples

std::array<double, 2> rates = { 1.0 / 10, 1.0 / 12 };
hyperexponential he(rates);
assert(he.probabilities()[0] == 0.5); // Phase probabilities will be equal and normalised to unity.

Construction from Initializer lists

hyperexponential_distribution(std::initializer_list<RealType> l1, std::initializer_list<RealType> l2);

Построено гиперэкспоненциальное распределение сфазовым вектором вероятностипараметром, заданнымскобчатым списком, определенным<l1>, ивектором скоростипараметром, заданнымскобчатым списком, определенным<l2>.

Parameters

Количество элементов списка фазовых вероятностей и списка ставок должно быть одинаковым.

Example

hyperexponential he = { { 0.5, 0.5 }, { 1.0 / 10, 1.0 / 12 } };

Construction from a single initializer list (all phase probabilities will be equal)

hyperexponential_distribution(std::initializer_list<RealType> l1);

Построение гиперэкспоненциального распределения свектором скоростипараметром, заданнымскобчатым списком, определенным<l1>, ивектором фазовой вероятности, установленным на равные фазовые вероятности (т.е. на вектор одинаковой длины<n>вектора скоростии с каждым элементом, установленным на<1.0/n>).

Parameters

Example

hyperexponential he = { 1.0 / 10, 1.0 / 12 };
assert(he.probabilities()[0] == 0.5);

Accessors

std::size_t num_phases() const;

Получает число фаз этого распределения (размер как векторов скорости, так и векторов вероятности).

Return Value

Неотрицательное целое число, представляющее число фаз этого распределения.

std::vector<RealType> probabilities() const;

Получаетфазовый вектор вероятностипараметр этого распределения.

	Note
	Возвращаемыми вероятностями являютсянормализованныеверсии значений параметров вероятности, прошедших в момент построения.

Return Value

Вектор неотрицательных действительных чисел, представляющийфазовый вектор вероятностипараметра этого распределения.

std::vector<RealType> rates() const;

Получаетвектор скоростипараметр этого распределения.

Return Value

Вектор положительных действительных чисел, представляющийвектор скоростипараметра этого распределения.

Warning

Тип возврата этих функций представляет собой вектор по значению. Это преднамеренно, поскольку мы хотим скрыть фактический контейнер, используемый внутри, который может быть подвержен будущим изменениям (например, для облегчения векторизации кода CDF и т. Д.). Пользователи должны отметить, что некоторые коды, которые в противном случае могли бы работать, не работают. Например, попытка вывести (нормализованные) вероятности: std::copy(he.probabilities().begin(), he.probabilities().end(), std::ostream_iterator<double>(std::cout, " ")); не удается компиляция или время выполнения, потому что типы итераторов несовместимы, но, например, std::cout << he.probabilities()[0] << ' ' << he.probabilities()[1] << std::endl; выдает ожидаемые значения. В общем случае, если вы хотите получить доступ к элементу возвращаемого контейнера, сначала назначьте переменную, а затем получите доступ к этим элементам: std::vector<double> t = he.probabilities(); std::copy(t.begin(), t.end(), std::ostream_iterator<double>(std::cout, " "));

Non-member Accessor Functions

Поддерживаются всеобычные нечленные функции доступа, которые являются общими для всех распределений:Кумулятивная функция распределения,Функция плотности вероятности,Количественная,Функция опасности,Кумулятивная функция опасности,среднее,медианное,режим,дисперсия,стандартное отклонение,искажение,куртоз,куртоз_избыток,диапазониподдержка.

Формулы для их расчета приведены в таблице ниже.

Accuracy

Гиперэкспоненциальное распределение реализуется в терминахЭкспоненциальное распределениеи как таковое должно иметь очень небольшие ошибки, обычноэпсилонили несколько.

Implementation

В следующей таблице: