Системы и технологии моделирования объектов СТМО Лаб. Раб. / Avdonkin / stmo5

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <vector>

using namespace std;

void Power(vector< vector<float> > &A, vector< vector<float> > &B, vector< vector<float> > &C, int n) {
    int i, j;

    C.resize(n);
    for (i = 0; i < n; i++) {
        C[i].resize(n);
        for (j = 0; j < n; j++) {
            float Sum = 0;
            for (int q = 0; q < n; q++) {
                Sum += A[i][q] * B[q][j];
            }
            C[i][j] = Sum;
        }
    }
}

float func_AND(float ff[150], int schet, float numberofproc, int x) {
    float f[150];
    for (int g = 0; g < schet; g++) {
        f[g] = ff[g];
    }
    float f_and[150];
    float M_and = 0;
    float D_and = 0;
    float nproc = numberofproc;
    float slag = 0;
    float sum = 0;
    int sch = schet;

    for (int k = 0; k < sch; k++) {
        f_and[k] = 0;
        for (int l = 1; l <= nproc; l++) {
            slag = f[k];

            for (int li = 2; li <= nproc; li++) {
                sum = 0;
                if (li <= l) {
                    for (int ki = 0; ki < k; ki++) {
                        sum = sum + f[ki];
                    }
                } else {
                    for (int ki = 0; ki <= k; ki++) {
                        sum = sum + f[ki];
                    }
                }
                slag = slag*sum;
            }
            f_and[k] = f_and[k] + slag;
        }
        M_and = M_and + (k + 1) * f_and[k];
    }

    float pdf1 = 0;
    for (int k = 0; k < sch; k++) {
        D_and = D_and + (k + 1 - M_and)*(k + 1 - M_and) * f_and[k];
        pdf1 += f_and[k];
    }

    cout << "f_and[" << x + 1 << "] = " << f_and[x] << endl;

    if (x == sch - 1) {
        cout << endl << "M_and = " << M_and << endl;
        cout << "D_and = " << D_and << endl << endl;
    }

    return f_and[x];
}

void func_OR(float ff[150], int schet, float numberofproc) {
    float f[150];
    for (int g = 0; g < schet; g++) {
        f[g] = ff[g];
    }
    float f_or[150];
    float M_or = 0;
    float D_or = 0;
    float nproc = numberofproc;
    float slag = 0;
    float sum = 0;
    int sch = schet;

    for (int k = 0; k < sch; k++) {
        f_or[k] = 0;
        for (int l = 1; l <= nproc; l++) {
            slag = f[k];
            for (int li = 2; li <= nproc; li++) {
                sum = 0;
                if (li <= l) {
                    for (int ki = k + 1; ki < sch; ki++) {
                        sum = sum + f[ki];
                    }
                } else {
                    for (int ki = k; ki < sch; ki++) {
                        sum = sum + f[ki];
                    }
                }
                slag = slag*sum;
            }
            f_or[k] = f_or[k] + slag;
        }
        M_or = M_or + (k + 1) * f_or[k];
    }

    for (int k = 0; k < sch; k++) {
        cout << "f_or[" << k + 1 << "] = " << f_or[k] << endl;
        D_or = D_or + (k + 1 - M_or)*(k + 1 - M_or) * f_or[k];
    }

    cout << endl;
    cout << "M_or = " << M_or << endl;
    cout << "D_or = " << D_or << endl;
    cout << endl;
}

float checkRowProbability(vector<float> row, float element) {
    float p = 0;
    for (int i = 0; i < row.size(); i++) {
        p += row[i];
    }
    p += element;

    return p;
}

bool buildMatrix(int size, vector< vector<float> > &matrix) {
    if (size <= 1) {
        cout << "Matrix size should be more than 1" << endl;
        return false;
    }
    matrix.resize(size);
    //построчное заполнение матрицы matrix
    for (int i = 0; i < size; i++) {

        vector<float> row;

        for (int j = 0; j < size; j++) {
            cout << "Enter " << i + 1 << "/" << j + 1 << " matrix element:" << endl;
            float element = 0;
            cin >> element;

            if (element > 1) {
                cout << "Probability of element could not be more than 1" << endl;
                j--;
                continue;
            }

            if ((checkRowProbability(row, element) > 1)) {
                cout << "Summary probability of row elements could not be more than 1" << endl;
                j--;
                continue;
            }

            if ((j == size - 1 & checkRowProbability(row, element) != 1)) {
                cout << "Summary probability of row elements should be equal 1" << endl;
                j--;
                continue;
            }
            row.push_back(element);
        }
        matrix[i] = row;
    }
    return true;
}

void printMatrix(vector< vector<float> > A, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%.1f ", A[i][j]);
        }
        cout << endl;
    }
    cout << endl;
}

int main() {
    cout << "Enter matrix size:" << endl;
    int s = 0;
    cin >> s;

    vector< vector<float> > A;

    while (!buildMatrix(s, A)) {
        cout << "Enter matrix size:" << endl;
        cin >> s;
    };

    int L = 12;

    vector< vector<float> > B;
    B.resize(s);

    vector< vector<float> > C;
    C.resize(s);

    float f[150];
    float check;
    float M = 0;
    float D = 0;
    float summf = 0;
    float delta = 0.0001;
    int n, i, j;
    n = s;

    //Вывод матрицы
    cout << "Matrix:" << endl;
    printMatrix(A, n);

    for (i = 0; i < n; i++) {
        B[i].resize(n);
        for (j = 0; j < n; j++) {
            B[i][j] = A[i][j];
        }
    }

    f[0] = A[0][n - 1]; //правый верхний элемент матрицы А
    summf = summf + f[0];
    check = 1 - f[0];
    M = M + 1 * f[0];

    float sumr = 0;
    int sch = 1;
    do {
        cout << "f[" << sch << "] = " << f[sch - 1] << endl;
        Power(B, A, C, n);

        f[sch] = C[0][n - 1] - B[0][n - 1];

        if (sch > L - 1)
            sumr = sumr + f[sch];

        summf = summf + f[sch];
        check = check - f[sch]; //Из единицы вычитаем f[k], и считаем дальше. Пока превышает дельта
        M = M + (sch + 1) * f[sch]; //МАТ. ОЖИДАНИЕ

        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++) {
                B[i][j] = C[i][j];
            }
        }
        sch++;
    } while (check > delta && sch < 150);

    cout << "f[" << sch << "] = " << f[sch - 1] << endl;
    cout << endl << "Probability density function = " << summf << endl;
    cout << "M = " << M << endl;

    for (i = 0; i < n; i++) {
        D = D + (i - M)*(i - M) * f[i - 1]; //ДИСПЕРСИЯ
    }
    cout << "D = " << D << endl;

    float sko = sqrt(D);
    if (M - 3 * sko > 0) {
        cout << "Confidence Interval = " << "[" << M << "-" << 3 * sko << ";"
                << M << "+" << 3 * sko << "]" << " or ""[" << M - 3 * sko << ";"
                << M + 3 * sko << "]" << endl;
    } else {
        cout << "Confidence Interval = [0;"
                << M << "+" << 3 * sko << "] or [0;"
                << M + 3 * sko << "]" << endl;
    }

    cout << "Risk of failure of the Provisional Rules R(" << L << ")=" << sumr << endl;

    float nproc = 50;
    float f_and[150];

    cout << endl << "_______________________AND_______________________" << endl << endl;
    for (int x = 0; x < sch; x++) {
        f_and[x] = func_AND(f, sch, nproc, x);
    }

    cout << endl << "______________________OR_____________________" << endl << endl;
    func_OR(f, sch, nproc);

    return 0;
}