API tools faq
paste
Advertisement
575

Untitled

575
May 26th, 2024
586
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 11.47 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <vector>
  3. #include <cmath>
  4. #include <iomanip>
  5.  
  6. using namespace std;
  7.  
  8. void print_params(map<string, double> &params) {
  9.     for (auto &arg : params) {
  10.         cout << arg.first << " = " << arg.second << endl;
  11.     }
  12. }
  13.  
  14. int main() {
  15.     double t_oj = 7;
  16.     double t_obs = 6.5;
  17.  
  18.     double t_inQ = 0.6;
  19.     double mu = 1 / t_obs;
  20.     double lmbd = 1 / t_oj;
  21.     double rho = lmbd / mu;
  22.     double omega = 1 / t_inQ;
  23.     double beta = omega / mu;
  24.  
  25.     cout << fixed << setprecision(6);
  26.     cout << "mu = " << mu << endl;
  27.     cout << "lmbd = " << lmbd << endl;
  28.     cout << "omega = " << omega << endl;
  29.     cout << "t_obs = " << t_obs << endl;
  30.     cout << "t_oj = " << t_oj << endl;
  31.     cout << "t_inQ = " << t_inQ << endl;
  32.     cout << "rho = " << rho << endl;
  33.     cout << "beta = " << beta << endl;
  34.  
  35.     int n = 1;
  36.     cout << "n = " << n << endl;
  37.  
  38.     auto get_params_limited_waiting = [](int n, double mu, double lmbd, double beta, double rho) {
  39.         map<string, double> params;
  40.         vector<double> p(1, 0);
  41.         for (int i = 0; i <= n; ++i) {
  42.             p[0] += pow(rho, i) / tgamma(i + 1);
  43.         }
  44.         vector<double> denominators(1, n + beta);
  45.         for (int i = 1; i < 10; ++i) {
  46.             denominators.push_back(denominators[i - 1] * (n + i * beta));
  47.         }
  48.         double tmp = 0;
  49.         for (int i = 0; i < 10; ++i) {
  50.             tmp += pow(rho, i + 1) / denominators[i];
  51.         }
  52.         p[0] = pow(p[0] + pow(rho, n) / tgamma(n + 1) * tmp, -1);
  53.         for (int i = 1; i <= n; ++i) {
  54.             p.push_back(pow(rho, i) / tgamma(i + 1) * p[0]);
  55.         }
  56.         for (int i = 0; i < 10; ++i) {
  57.             p.push_back(pow(rho, n) / tgamma(n + 1) * pow(rho, i + 1) / denominators[i] * p[0]);
  58.         }
  59.         params["p"] = p[0]; // Only storing the first p value
  60.         double k = n;
  61.         for (int i = 0; i <= n; ++i) {
  62.             k -= (n - i) * p[i];
  63.         }
  64.         params["k"] = k;
  65.         params["P_och"] = 1;
  66.         for (int i = 0; i <= n; ++i) {
  67.             params["P_och"] -= p[i];
  68.         }
  69.         params["P_ob"] = k / rho;
  70.         params["P_otk"] = 0;
  71.         params["P_syst"] = 1;
  72.         params["Q"] = params["P_ob"];
  73.         params["A"] = lmbd * params["Q"];
  74.         params["L_ob"] = k;
  75.         params["L_och"] = (rho - k) / beta;
  76.         params["L_syst"] = params["L_ob"] + params["L_och"];
  77.         params["P_uh"] = 1 - params["P_ob"];
  78.         params["nu_uh"] = lmbd - mu * k;
  79.         params["T_ob"] = params["L_ob"] / lmbd;
  80.         params["T_och"] = params["L_och"] / lmbd;
  81.         params["T_syst"] = params["L_syst"] / lmbd;
  82.  
  83.         return params;
  84.     };
  85.  
  86.     print_params(get_params_limited_waiting(n, mu, lmbd, beta, rho));
  87.  
  88.     n = 3;
  89.     cout << "n = " << n << endl;
  90.  
  91.     print_params(get_params_limited_waiting(n, mu, lmbd, beta, rho));
  92.  
  93.     n = 1;
  94.     int i = 4;
  95.  
  96.     cout << "n = " << n << endl;
  97.     cout << "i = " << i << endl;
  98.  
  99.     auto get_params_closed = [](int n, double mu, double lmbd, double rho, int i) {
  100.         map<string, double> params;
  101.         vector<double> p(1, 0);
  102.         for (int k = 0; k <= n; ++k) {
  103.             p[0] += tgamma(i + 1) / tgamma(i - k + 1) * pow(rho, k) / tgamma(k + 1);
  104.         }
  105.         for (int k = n + 1; k <= i; ++k) {
  106.             p[0] += pow(rho, n) / tgamma(n + 1) * tgamma(i + 1) / tgamma(i - k + 1) * pow(rho, k - n) / pow(n, k - n);
  107.         }
  108.         p[0] = pow(p[0], -1);
  109.         for (int k = 1; k <= n; ++k) {
  110.             p.push_back(tgamma(i + 1) / tgamma(i - k + 1) * pow(rho, k) / tgamma(k + 1) * p[0]);
  111.         }
  112.         for (int k = n + 1; k <= i; ++k) {
  113.             p.push_back(tgamma(i + 1) / tgamma(i - k + 1) * pow(rho, k) / (tgamma(n + 1) * pow(n, k - n)) * p[0]);
  114.         }
  115.         params["p"] = p[0]; // Only storing the first p value
  116.         double k = n;
  117.         for (int j = 0; j <= n; ++j) {
  118.             k -= (n - j) * p[j];
  119.         }
  120.         params["k"] = k;
  121.         params["P_och"] = 0;
  122.         for (int j = n + 1; j <= i; ++j) {
  123.             params["P_och"] += p[0] * pow(rho, n) / tgamma(n + 1) * tgamma(i + 1) / tgamma(i - j + 1) * pow(rho, j - n) / pow(n, j - n);
  124.         }
  125.         params["P_ob"] = 1;
  126.         params["P_otk"] = 0;
  127.         params["P_syst"] = 1;
  128.         params["Q"] = 1;
  129.         params["A"] = mu * k;
  130.         params["L_ob"] = k;
  131.         params["L_och"] = i - k * (1 / rho + 1);
  132.         params["L_syst"] = params["L_ob"] + params["L_och"];
  133.         params["N_akt"] = params["A"] / lmbd;
  134.         params["N_pas"] = i - params["N_akt"];
  135.         params["nu"] = params["A"];
  136.         params["P_akt"] = params["N_akt"] / i;
  137.         params["T_ob"] = params["L_ob"] / params["nu"];
  138.         params["T_och"] = params["L_och"] / params["nu"];
  139.         params["T_syst"] = params["L_syst"] / params["nu"];
  140.  
  141.         return params;
  142.     };
  143.  
  144.     print_params(get_params_closed(n, mu, lmbd, rho, i));
  145.  
  146.     n = 3;
  147.     cout << "n = " << n << endl;
  148.  
  149.     print_params(get_params_closed(n, mu, lmbd, rho, i));
  150.  
  151.     n = 4;
  152.     cout << "n = " << n << endl;
  153.  
  154.     auto get_params_rejections = [](int n, double mu, double lmbd, double rho) {
  155.         map<string, double> params;
  156.         vector<double> p(1, 1);
  157.         for (int i = 1; i <= n; ++i) {
  158.             p[0] += pow(rho, i) / tgamma(i + 1);
  159.         }
  160.         p[0] = pow(p[0], -1);
  161.         for (int i = 1; i <= n; ++i) {
  162.             p.push_back(pow(rho, i) / tgamma(i + 1) * p[0]);
  163.         }
  164.         params["p"] = p[0];
  165.         params["P_otk"] = p.back();
  166.         params["Q"] = 1 - params["P_otk"];
  167.         params["A"] = lmbd * params["Q"];
  168.         params["k"] = params["A"] / mu;
  169.         params["L_ob"] = params["A"] / mu;
  170.         params["T_ob"] = params["L_ob"] / lmbd;
  171.  
  172.         return params;
  173.     };
  174.  
  175.     auto get_params_rejections_plus = [](int n, double mu, double lmbd, double rho) {
  176.         map<string, double> params;
  177.         vector<double> p = {n / (rho + n), rho / (rho + n)};
  178.         params["p+"] = p[0]; // Only storing the first p value
  179.         params["P_otk+"] = p[1];
  180.         params["Q+"] = 1 - params["P_otk+"];
  181.         params["A+"] = lmbd * params["Q+"];
  182.         params["k+"] = params["A+"] / mu;
  183.         params["L_ob+"] = p[1];
  184.         params["T_ob+"] = params["L_ob+"] / lmbd;
  185.  
  186.         return params;
  187.     };
  188.  
  189.     print_params(get_params_rejections(n, mu, lmbd, rho));
  190.     print_params(get_params_rejections_plus(n, mu, lmbd, rho));
  191.  
  192.     n = 3;
  193.     double psi = rho / n;
  194.  
  195.     cout << "n = " << n << endl;
  196.     cout << "psi = rho/n = " << psi << endl;
  197.  
  198.     auto get_params_endless_queue = [](int n, double mu, double lmbd, double rho) {
  199.         map<string, double> params;
  200.         vector<double> p(1, 1);
  201.         for (int i = 1; i <= n; ++i) {
  202.             p[0] += pow(rho, i) / tgamma(i + 1);
  203.         }
  204.         p[0] += pow(rho, n + 1) / (tgamma(n + 1) * (n - rho));
  205.         p[0] = pow(p[0], -1);
  206.         for (int i = 1; i <= n; ++i) {
  207.             p.push_back(pow(rho, i) / tgamma(i + 1) * p[0]);
  208.         }
  209.         for (int i = 1; i < 150; ++i) {
  210.             p.push_back(pow(rho, n + i) / (tgamma(n + 1) * pow(n, i)) * p[0]);
  211.         }
  212.         params["p"] = p[0]; // Only storing the first p value
  213.         params["P_och"] = pow(rho, n + 1) * p[0] / (tgamma(n + 1) * (n - rho));
  214.         params["P_otk"] = 0;
  215.         params["Q"] = 1 - params["P_otk"];
  216.         params["A"] = lmbd * params["Q"];
  217.         params["k"] = params["A"] / mu;
  218.         params["L_ob"] = params["A"] / mu;
  219.         params["L_och"] = n * params["P_och"] / (n - rho);
  220.         params["L_syst"] = params["L_ob"] + params["L_och"];
  221.         params["T_ob"] = params["L_ob"] / lmbd;
  222.         params["T_och"] = params["L_och"] / lmbd;
  223.         params["T_syst"] = params["L_syst"] / lmbd;
  224.  
  225.         return params;
  226.     };
  227.  
  228.     auto get_params_endless_queue_plus = [](int n, double lmbd, double rho, double psi) {
  229.         map<string, double> params;
  230.         vector<double> p = {1 - psi};
  231.         for (int i = 1; i < 10; ++i) {
  232.             p.push_back(pow(psi, i) * (1 - psi));
  233.         }
  234.         params["p+"] = p[0];
  235.         params["P_och+"] = pow(psi, 2);
  236.         params["P_otk+"] = 0;
  237.         params["Q+"] = 1;
  238.         params["A+"] = lmbd;
  239.         params["k+"] = rho;
  240.         params["L_ob+"] = psi;
  241.         params["L_och+"] = pow(psi, 2) / (1 - psi);
  242.         params["L_syst+"] = params["L_ob+"] + params["L_och+"];
  243.         params["T_ob+"] = params["L_ob+"] / lmbd;
  244.         params["T_och+"] = params["L_och+"] / lmbd;
  245.         params["T_syst+"] = params["L_syst+"] / lmbd;
  246.  
  247.         return params;
  248.     };
  249.  
  250.     print_params(get_params_endless_queue(n, mu, lmbd, rho));
  251.     print_params(get_params_endless_queue_plus(n, lmbd, rho, psi));
  252.  
  253.     n = 2;
  254.     int m = 4;
  255.     psi = rho / n;
  256.  
  257.     cout << "n = " << n << endl;
  258.     cout << "m = " << m << endl;
  259.     cout << "psi = rho/n = " << psi << endl;
  260.  
  261.     auto get_params_limited_queue = [](int n, int m, double mu, double lmbd, double rho) {
  262.         map<string, double> params;
  263.         vector<double> p(1, 1);
  264.         for (int i = 1; i <= n; ++i) {
  265.             p[0] += pow(rho, i) / tgamma(i + 1);
  266.         }
  267.         p[0] += pow(rho, n + 1) * (1 - pow(rho / n, m)) / (tgamma(n + 1) * n * (1 - rho / n));
  268.         p[0] = pow(p[0], -1);
  269.         for (int i = 1; i <= n; ++i) {
  270.             p.push_back(pow(rho, i) / tgamma(i + 1) * p[0]);
  271.         }
  272.         for (int i = 1; i <= m; ++i) {
  273.             p.push_back(pow(rho, n + i) / (tgamma(n + 1) * pow(n, i)) * p[0]);
  274.         }
  275.         params["p"] = p[0]; // Only storing the first p value
  276.         params["P_och"] = pow(rho, n + 1) * (1 - pow(rho / n, m)) / (tgamma(n + 1) * n * (1 - rho / n)) * p[0];
  277.         params["P_otk"] = pow(rho, n + m) / (pow(n, m) * tgamma(n + 1)) * p[0];
  278.         params["Q"] = 1 - params["P_otk"];
  279.         params["A"] = lmbd * params["Q"];
  280.         params["k"] = params["A"] / mu;
  281.         params["L_ob"] = params["A"] / mu;
  282.         params["L_och"] = pow(rho, n + 1) / (n * tgamma(n + 1)) * (1 - pow(rho / n, m) * (m + 1 - m * rho / n)) / pow(1 - rho / n, 2) * p[0];
  283.         params["L_syst"] = params["L_ob"] + params["L_och"];
  284.         params["T_ob"] = params["L_ob"] / lmbd;
  285.         params["T_och"] = params["L_och"] / lmbd;
  286.         params["T_syst"] = params["L_syst"] / lmbd;
  287.  
  288.         return params;
  289.     };
  290.  
  291.     auto get_params_limited_queue_plus = [](int n, int m, double lmbd, double psi) {
  292.         map<string, double> params;
  293.         vector<double> p = {(1 - psi) / (1 - pow(psi, m + 2))};
  294.         for (int i = 1; i <= m + 1; ++i) {
  295.             p.push_back(pow(psi, i) * p[0]);
  296.         }
  297.         params["p+"] = p[0]; // Only storing the first p value
  298.         params["P_och+"] = pow(psi, 2) * (1 - pow(psi, m)) / (1 - pow(psi, m + 2));
  299.         params["P_otk+"] = pow(psi, m + 1) * (1 - psi) / (1 - pow(psi, m + 2));
  300.         params["Q+"] = 1 - params["P_otk+"];
  301.         params["A+"] = lmbd * params["Q+"];
  302.         params["k+"] = n * psi * (1 - pow(psi, m + 1)) / (1 - pow(psi, m + 2));
  303.         params["L_ob+"] = psi * params["Q+"];
  304.         params["L_och+"] = pow(psi, 2) * (1 - pow(psi, m) * (m + 1 - m * psi)) / ((1 - pow(psi, m + 2)) * (1 - psi));
  305.         params["L_syst+"] = params["L_ob+"] + params["L_och+"];
  306.         params["T_ob+"] = params["L_ob+"] / lmbd;
  307.         params["T_och+"] = params["L_och+"] / lmbd;
  308.         params["T_syst+"] = params["L_syst+"] / lmbd;
  309.  
  310.         return params;
  311.     };
  312.  
  313.     print_params(get_params_limited_queue(n, m, mu, lmbd, rho));
  314.     print_params(get_params_limited_queue_plus(n, m, lmbd, psi));
  315.  
  316.     return 0;
  317. }
  318.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!