Системы и технологии моделирования объектов СТМО Лаб. Раб. / Avdonkin / Avdonkin_STMO_7
.docxФедеральное государственное бюджетное образовательное учреждение
высшего профессионального образования
«Санкт-Петербургский Государственный Университет им. проф. М. А. Бонч-Бруевича»
Кафедра информационных управляющих систем
Дисциплина «Системы и технологии моделирования объектов»
Специальность 230201 «Информационные системы и технологии»
Лабораторная работа №7
«Разработка программного приложения для определения динамических характеристик функционирования объектов при его моделировании в классе логических моделей»
Выполнил: студент группы ИСТ-81 Авдонкин Д. О.
Преподаватель: Птицына Л.К.
Санкт-Петербург
2012 г.
Задача:
Расширение приложения, данного в прототипе к лабораторной работе и его реализация.
Разработка программы для оценки динамических характеристик системы при объединении процессов по функциям И, ИЛИ и 2 из 3.
Анализ полученных результатов, построение зависимостей времени выполнения задачи от числа процессов. Расчет коэффициентов эффективности.
Проверка правильности работы программы для детерминированного случая:
Matrix:
0.0 1.0 0.0 0.0 0.0 0.0
0.0 0.0 1.0 0.0 0.0 0.0
0.0 0.0 0.0 1.0 0.0 0.0
0.0 0.0 0.0 0.0 1.0 0.0
0.0 0.0 0.0 0.0 0.0 1.0
0.0 0.0 0.0 0.0 0.0 1.0
f[1] = 0
f[2] = 0
f[3] = 0
f[4] = 0
f[5] = 1
Probability density function = 1
M = 5
D = 0
Confidence Interval = [5-0;5+0] or [5;5]
Risk of failure of the Provisional Rules R(1)=0
_______________________AND_______________________
f_and[1] = 0
f_and[2] = 0
f_and[3] = 0
f_and[4] = 0
f_and[5] = 1
M_and = 5
D_and = 0
______________________OR_____________________
f_or[1] = 0
f_or[2] = 0
f_or[3] = 0
f_or[4] = 0
f_or[5] = 1
M_or = 5
D_or = 0
Вывод:
Результаты выполнения программы верны.
Результаты работы программы:
Matrix:
0.0 0.5 0.5 0.0 0.0 0.0
0.0 0.0 0.5 0.5 0.0 0.0
0.0 0.0 0.0 0.0 1.0 0.0
0.0 0.0 0.0 0.0 0.5 0.5
0.0 0.0 0.0 0.0 0.0 1.0
0.0 0.0 0.0 0.0 0.0 1.0
f[1] = 0
f[2] = 0
f[3] = 0.625
f[4] = 0.375
Probability density function = 1
M = 3.375
D = 0.234375
Confidence Interval = [3.375-1.45237;3.375+1.45237] or [1.92263;4.82737]
Risk of failure of the Provisional Rules R(1)=0
_______________________AND_______________________
f_and[1] = 0
f_and[2] = 0
f_and[3] = 6.22302e-11
f_and[4] = 1
M_and = 4
D_and = 6.2287e-11
______________________OR_____________________
f_or[1] = 0
f_or[2] = 0
f_or[3] = 1
f_or[4] = 5.02995e-22
M_or = 3
D_or = 5.02995e-22
_______________________2of3_______________________
f_2of3[1] = 0
f_2of3[2] = 0
f_2of3[3] = 0.683594
f_2of3[4] = 0.228516
M_2of3 = 2.96484
D_2of3 = 0.24571
______________________RESULT_____________________
f_result[1] = 0
f_result[2] = 0
f_result[3] = 0
f_result[4] = 0
f_result[5] = 0
f_result[6] = 0
f_result[7] = 2.65876e-11
f_result[8] = 0.427246
f_result[9] = 0.39917
f_result[10] = 0.0856934
f_result[11] = 7.47005e-20
f_result[12] = 2.49713e-20
f_result[13] = 3.40284e-39
f_result[14] = 1.13679e+20
f_result[15] = 3.80013e+19
f_result[16] = 2.49713e-20
f_result[17] = 1.20164e+20
f_result[18] = 4.0169e+19
f_result[19] = 0
f_result[20] = 2.55014e-39
f_result[21] = 1.20164e+20
f_result[22] = 4.0169e+19
f_result[23] = 2.56174e-39
f_result[24] = 7.47005e-20
f_result[25] = 2.49713e-20
f_result[26] = 3.40284e-39
f_result[27] = 3.40267e-39
f_result[28] = 1.13678e+20
f_result[29] = 3.8001e+19
f_result[30] = 4.44134e-39
f_result[31] = 3.47607e-39
f_result[32] = 3.41052e-39
f_result[33] = 1.20164e+20
f_result[34] = 4.0169e+19
f_result[35] = 2.49713e-20
f_result[36] = 0
f_result[37] = 4.24415e+33
f_result[38] = 2.18849e+33
f_result[39] = 2.57312e+32
f_result[40] = 8.96831e-44
f_result[41] = 7.69738e+32
f_result[42] = 2.57312e+32
f_result[43] = 1.31792e+20
f_result[44] = 4.40561e+19
f_result[45] = 1.24308e+20
f_result[46] = 4.15545e+19
f_result[47] = 1.26117e-44
f_result[48] = 0
f_result[49] = 0
f_result[50] = 0
M_result = 2.92598e+35
D_result = inf
Исходный код программы:
#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;
}
float func_2of3(float ff[150], int schet, int x) {
float f[150];
for (int g = 0; g < schet; g++) {
f[g] = ff[g];
}
float f_23[150];
float M_23 = 0;
float D_23 = 0;
int sch = schet;
float sum1 = 0;
float sum2 = 0;
for (int k = 0; k < sch; k++) {
f_23[k] = 0;
//1
sum1 = 0;
sum2 = 0;
for (int ki = 0; ki < sch; ki++) {
if (ki <= k) {
sum1 += f[ki];
}
if (ki >= k) {
sum2 += f[ki];
}
}
f_23[k] = f_23[k] + f[k] * sum1*sum2;
//2
sum1 = 0;
sum2 = 0;
for (int ki = 0; ki < sch; ki++) {
if (ki < k) {
sum1 += f[ki];
}
if (ki >= k) {
sum2 += f[ki];
}
}
f_23[k] = f_23[k] + f[k] * sum1*sum2;
//3
sum1 = 0;
sum2 = 0;
for (int ki = 0; ki < sch; ki++) {
if (ki <= k) {
sum1 += f[ki];
}
if (ki > k) {
sum2 += f[ki];
}
}
f_23[k] = f_23[k] + f[k] * sum1*sum2;
//4
sum1 = 0;
sum2 = 0;
for (int ki = 0; ki < sch; ki++) {
if (ki < k) {
sum1 += f[ki];
}
if (ki > k) {
sum2 += f[ki];
}
}
f_23[k] = f_23[k] + f[k] * sum1*sum2;
//5
sum1 = 0;
sum2 = 0;
for (int ki = 0; ki < sch; ki++) {
if (ki <= k) {
sum1 += f[ki];
}
if (ki > k) {
sum2 += f[ki];
}
}
f_23[k] = f_23[k] + f[k] * sum1*sum2;
//6
sum1 = 0;
sum2 = 0;
for (int ki = 0; ki < sch; ki++) {
if (ki < k) {
sum1 += f[ki];
}
if (ki > k) {
sum2 += f[ki];
}
}
f_23[k] = f_23[k] + f[k] * sum1*sum2;
//7
sum1 = 0;
sum2 = 0;
for (int ki = 0; ki < sch; ki++) {
if (ki < k) {
sum1 += f[ki];
}
}
f_23[k] = f_23[k] + f[k] * f[k] * sum2;
M_23 = M_23 + (k + 1) * f_23[k];
}
float pdf2 = 0;
for (int k = 0; k < sch; k++) {
D_23 = D_23 + (k + 1 - M_23)*(k + 1 - M_23) * f_23[k];
pdf2 += f_23[k];
}
cout << "f_2of3[" << x + 1 << "] = " << f_23[x] << endl;
if (x == sch - 1) {
cout << endl << "M_2of3 = " << M_23 << endl;
cout << "D_2of3 = " << D_23 << endl << endl;
}
return f_23[x];
}
void func_RESULT(float f1[150], float f2[150], float f3[150], int schet) {
float f_result[150];
float M_result = 0;
float D_result = 0;
int sch = schet;
float f22[150];
float f33[150];
float pdf3 = 0;
for (int k = 0; k < 2 * sch; k++) {
f22[k] = 0;
for (int ki = 0; ki < k; ki++) {
f22[k] += f1[ki] * f2[k - ki];
}
}
for (int k = 0; k < 50; k++)//k<3*sch=3*34=102
{
f_result[k] = 0;
f33[k] = 0;
for (int ki = 0; ki < k; ki++) {
f33[k] += f22[ki] * f3[k - ki];
}
f_result[k] = f33[k];
cout << "f_result[" << k + 1 << "] = " << f_result[k] << endl;
M_result = M_result + (k + 1) * f_result[k];
}
for (int k = 0; k < 50; k++) {
pdf3 += f_result[k];
D_result = D_result + (k + 1 - M_result)*(k + 1 - M_result) * f_result[k];
}
cout << endl << "M_result = " << M_result << endl;
cout << "D_result = " << D_result << endl << 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);
float f_2of3[150];
cout << endl << "_______________________2of3_______________________" << endl << endl;
for (int x = 0; x < sch; x++) {
f_2of3[x] = func_2of3(f, sch, x);
}
cout << endl << "______________________RESULT_____________________" << endl << endl;
func_RESULT(f_and, f, f_2of3, sch);
return 0;
}