Имитационная модель функционирования системы с отказами
Особенности имитационного моделирования, решение задач с помощью обратных функций. Описание метода обратных функций, вероятность работы системы на промежутке времени. Характеристика метода Крамера, применение и специфика метода наименьших квадратов.
| Рубрика | Экономико-математическое моделирование |
| Вид | курсовая работа |
| Язык | русский |
| Дата добавления | 24.09.2018 |
| Размер файла | 1,5 M |
Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
Размещено на http://www.allbest.ru/
Размещено на http://www.allbest.ru/
ФГБОУ ВО
Уфимский государственный авиационный технический университет
Кафедра АСУ
Дисциплина «Математическое имитационное моделирование и планирование экспериментов»
Пояснительная записка
к курсовому проекту
Имитационная модель функционирования системы с отказами
Выполнил студент группы ПИ-316сз
Афанасьева А.А.
Уфа 2017
Содержание
- 1. Цель работы
- 2. Содержание работы
- 3. Теоретический материал
- 3.1 Имитационное моделирование
- 3.1.1 Решение «в лоб»
- 3.1.2 Метод обратных функций
- 3.1.3 Решение с помощью обратных функций
- 3.2 Сглаживание функции
- 3.2.1 Метод наименьших квадратов
- 3.2.2 Метод Крамера
- 3.2.3 Получение полинома
- 3.3 Среднее время работы системы
- 3.4 Вероятность работы системы на промежутке времени
- 4. Выполнение работы
- 4.1 Построение графиков распределения подсистем
- 4.2 Построение графиков вероятности работы подсистем
- 4.3 Построение графика безотказной работы системы
- Вывод
- Список литературы
- Приложение А Исходный код программы
1.
1. Цель работы
Целью данного курсового проекта является разработка программного обеспечения, представляющего собой имитационную модель функционирования некоторой системы, отдельные подсистемы которой могут отказывать в процессе работы.
2. Содержание работы
Система на рис. 1 задана в виде логической схемы соединения подсистем. При этом считают, что подсистема работоспособна, если ее выход связан с входом. Другими словами, если связь отсутствует (существует обрыв), подсистема неработоспособна. Это относится и к системе в целом. Подобная схема замещения эквивалентна электрической цепи: если по ней протекает ток, система работоспособна, если цепь оборвана - система отказала.
Рисунок 1. Логическая схема работы системы
Для каждой подсистемы задан закон распределения времени, в течение которого подсистема работоспособна.
Подсистема 1: Равномерное распределение с параметрами a=2 час, b=14 часов.
Подсистема 2: Экспоненциальное распределение с параметром =1/10 1/час;
Подсистема 3: Симметричное треугольное распределение , заданное на отрезке с=2 часа, d=18 часов; одно случайное число, распределенное по этому закону, может быть получено как сумма двух случайных чисел с равномерным законом на интервале [c/2, d/2];
Подсистема 4: Нормальное (усечено-нормальное) распределение с параметрами m=12 часов, у=2 часа;
Подсистема 5: Нормальное распределение с параметрами m=16 часов, у=2 часа;
Подсистема 6: Равномерное распределение с параметрами a=1 час, b=29 часов.
Подсистема 7: Экспоненциальное распределение с параметром =1/20 1/час;
Требуется по этим данным построить имитационную модель функционирования системы и с ее помощью определить следующие характеристики системы как целого:
1) закон распределения времени безотказной работы всей системы :
a. Смоделировать реализаций случайного процесса функционирования системы для различных значений и получить таким образом ряд значений ;
b. Полученный ряд сгладить непрерывной функцией по методу наименьших квадратов;
2) среднее время безотказной работы системы;
3) вероятность того, что система не откажет в течение заданного промежутка времени (значения границ выбрать самостоятельно);
4) построить графики законов распределения времени безотказной работы подсистем (для этого модель не требуется), сравнить с результатом п. 1) и провести сравнительный анализ безотказности системы и ее подсистем.
3. Теоретический материал
3.1. Имитационное моделирование
Имитационное моделирование - воспроизведение на ЭВМ (имитация) процесса функционирования исследуемой системы с соблюдением логической и временной последовательности реальных событий.
При имитационном моделировании тип и структура моделирующего алгоритма обусловлены не типом уравнений и не применяемым для их решения численным методом, а имитацией реальных явлений с сохранением их логической структуры, временной последовательности и состава информации о состояниях процесса.
Рассмотрим, как проводится имитационное моделирование. Для этого возьмем в качестве примера систему из трех подсистем (блоков), которая изображена на рис.2.
Рисунок 2. Пример системы из трех блоков
Система функционирует нормально, если исправен хотя бы один из блоков 1 и 2, а также исправен блок 3. Функции распределения времени безотказной работы блоков известны. Требуется найти вероятность безотказной работы системы в момент времени .
3.1.1 Решение «в лоб»
Если время работы системы , а - время безотказной работы элемента с номером , то:
· событие означает исправную работу элемента за время;
· событие означает отказ элемента к времени
Заметим, что - случайная величина, распределенная по закону , который известен по условию.
Моделирование случайного события «исправная работа го элемента за время заключается:
1) в получении случайного числа , распределенного по закону ;
2) в проверке истинности логического выражения . Если оно истинно, то -й элемент исправен, если ложно - он отказал.
Для моделирования фиксированного момента времени используют следующий алгоритм:
1. Положить . В данном случае - счетчик числа реализаций случайного процесса, а - счетчик числа «успехов».
2. Получить три случайных числа , распределенных соответственно по законам .
3. Проверить истинность логического выражения:
Если , то положить и перейти к шагу 4, иначе просто перейти к шагу 4.
4. Положить .
5. Если , то перейти к шагу 2, иначе вычислить и вывести . Здесь - число реализаций случайного процесса, от которого зависят точность и достоверность результатов.
6. Стоп.
Значение необходимо задавать по соображениям обеспечения точности о достоверности статистической оценки искомой величины . Данное значение рекомендуется задать в промежутке .
Данное решение можно упростить, изменив способ получения случайных чисел. Для этого воспользуемся методом обратных функций.
3.1.2 Метод обратных функций
Существует лемма, которая гласит: Если случайная величина имеет плотность распределения , то случайная величина имеет равномерный закон распределения на интервале , т.е.
Также существует теорема. Пусть - функция распределения некоторой случайной величины - случайная величина с равномерным законом распределения на интервале . Тогда случайная величина , где - обратная функция , подчиняется закону распределения .
Исходя из этого, случайное число , подчиняющееся закону , определяют по формуле:
3.1.3 Решение с помощью обратных функций
Если учесть, что на практике функция - монотонно возрастающая, то можно для заданного времени безотказной работы найти значения
Тогда проверка работоспособности элементов сведется к проверке условия , где - равномерно распределенное на промежутке случайное число, - номер элемента, - номер очередной реализации случайного процесса.
Это равносильно условию , причем процедура вычисления обратной функции здесь не требуется.
Можно также существенно упростить логическое выражение, если перейти от события «безотказная работа системы» к событию «отказ системы». Отказ системы означает истинность выражения
С учетом данных упрощений, алгоритм принимает следующий вид:
1. По заданному времени безотказной работы вычислить
2. Положить .
3. Получить три равномерно распределенных на случайных числа
4. Проверить истинность логического выражения
Если оно истинно, то положить и перейти к шагу 5, иначе просто перейти к шагу 5.
5. Положить .
6. Если , то перейти к шагу 3, иначе вычислить и вывести
7. Стоп.
При построении закона распределения эти действия необходимо повторять последовательно для всех значений t от 0, пока , т. е до момента, когда вероятность безотказной работы опустится до значения 0.
3.2 Сглаживание функции
3.2.1 Метод наименьших квадратов
Пусть имеется значений некоторой переменной и соответствующих переменных . Задача заключается в том, чтобы взаимосвязь между и аппроксимировать некоторой функцией , известной с точностью до некоторых неизвестных параметров , то есть фактически найти наилучшие значения параметров , максимально приближающие значения к фактическим значениям .
Фактически, это сводится к случаю «решения» переопределенной системы уравнений относительно :
В регрессионном анализе используются вероятностные модели зависимости между переменными , где - случайные ошибки модели.
Соответственно, отклонения наблюдаемых значений от модельных предполагаются уже в самой модели. Сущность метода наименьших квадратов заключается в том, чтобы найти такие параметры , при которых сумма квадратов отклонений будет минимальной: , где .
В общем случае решение этой задачи может осуществляться численными методами оптимизации (минимизации). В этом случае говорят о нелинейном методе наименьших квадратов. Во многих случаях можно получить аналитическое решение. Для решения задачи минимизации необходимо найти стационарные точки функции R S S ( b ) {\displaystyle RSS(b)}, продифференцировав её по неизвестным параметрам b {\displaystyle b}, приравняв производные к нулю и решив полученную систему уравнений:
Преобразовав данное уравнение, получим:
Перепишем систему в виде:
В итоге получилась система уравнений, которую можно решить, например, методом Крамера.
3.2.2 Метод Крамера
Мы можем использовать данный метод, поскольку, в данном случае, имеется система уравнений с неизвестными, и каждый элемент отличается от нуля.
Систему уравнений нужно записать в виде произведения матриц:
Найдем определитель данной матрицы (). Для этого нужно привести матрицу к треугольному виду, затем перемножить элементы главной диагонали.
Элементы можно найти следующим образом:
где j-ый столбец матрицы системы заменяется столбцом свободных членов.
3.2.3 Получение полинома
После решения системы методом Крамера, необходимо подставить найденные значения в полином вида:
3.3 Среднее время работы системы
В теории надежности под этим термином понимается математическое ожидание времени исправной работы системы:
Практически, среднее время исправной работы системы равно:
где - количество испытаний над системой.
3.4 Вероятность работы системы на промежутке времени
На промежутке времени , вероятность работы системы определяется как отношение вероятности работы за позднее время к вероятности работы за раннее время:
где - вероятность работы системы за время .
4. Выполнение работы
Данный курсовой проект выполняется в среде Microsoft Visual Studio 2012 на языке программирования С#.
Исходный код программы описан в приложении А
4.1 Построение графиков распределения подсистем
Рисунок 3. График функции блока 1
Рисунок 4. График функции блока 2
Рисунок 5. График функции блока 3
Рисунок 6. График функции блока 4
Рисунок 7. График функции блока 5
Рисунок 8. График функции блока 6
Рисунок 9. График функции блока 7
4.2 Построение графиков вероятности работы подсистем
Рисунок 10. Вероятность работы блока 1
Рисунок 11. Вероятность работы блока 2
Рисунок 12. Вероятность работы блока 3
Рисунок 13. Вероятность работы блока 4
Рисунок 14. Вероятность работы блока 5
Рисунок 15. Вероятность работы блока 6
Рисунок 16. Вероятность работы блоков 7
Исходя из построенных графиков, видно, что вероятность работы подсистем со временем уменьшается, следовательно, вероятность работы системы так же будет уменьшаться со временем.
4.3 Построение графика безотказной работы системы
Рисунок 17. График работы системы
крамер моделирование функция
Рисунок 18. График сглаженной функции работы системы
На графиках выше (рис. 17,18) синим цветом обозначен график вычисленной функции, а красным - график сглаженной функции (полинома 5 степени). При вызове функции сглаживания, также появляется и аналитическое решение системы уравнений.
Вывод
В ходе выполнения данного курсового проекта было получено программное обеспечение на языке С#, позволяющее имитировать некоторую систему с отказами, а также определить:
· закон распределения времени безотказной работы всей системы :
o моделирование реализаций случайного процесса функционирования системы для различных значений и получение, таким образом, ряда значений ;
o сглаживание полученного ряда непрерывной функцией по методу наименьших квадратов;
· среднее время безотказной работы системы;
· вероятность того, что система не откажет в течение заданного промежутка времени ;
· законы распределения времени безотказной работы подсистем, а также их сравнение с законом распределения времени безотказной работы системы: вероятность безотказной работы в обоих случаях уменьшается со временем.
Список литературы
1. Методические указания к курсовому проекту по дисциплине «Математическое имитационное моделирование и планирование экспериментов»
2. Метод наименьших квадратов // Высшая математика - просто и доступно! [Электронный ресурс]. URL: http://www.mathprofi.ru/metod_naimenshih_kvadratov.html (дата обращения: 27.10.2016)
3. Метод Крамера // Википедия [Электронный ресурс]. URL: https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9A%D1%80%D0%B0%D0%BC%D0%B5%D1%80%D0%B0 (дата обращения: 29.10.2016)
4. Лекция 1 // Надежность АСОИиУ [Электронный ресурс]. URL: http://nadegnost.narod.ru/lection1.html (дата обращения: 21.10.2016)
5. Ушаков И.А. Курс теории надежности систем: учеб. пособие для вузов-М.:Дрофа, 2008-239 стр
Приложение А Исходный код программы
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Text;
using System.Drawing.Imaging;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Collections;
namespace Imitazionnay_model
{
public partial class MainForm : Form
{
public MainForm()
{
InitializeComponent();
}
static double[] Parr = new double[200];
static double[] KParr = new double[200];
static double[,] MATR = new double[50, 50];
double xmin = 0, xmax, ymin = 0, ymax;
double hx, hy, mx, my;
int ax1, ax2, ay1, ay2;
int d, c, sx, sy;
Pen pn = new Pen(Color.Maroon, 3); //Перо для графика
Pen pen = new Pen(Color.Blue, 2); //Перо для графика 2
Pen pn1 = new Pen(Color.Green, 1); //Перо для сетки
Pen pn2 = new Pen(Color.Black, 2); //Перо для осей
Font fn = new Font("Arial", 12); // Шрифт для осей
Font fn1 = new Font("Arial", 9); // Шрифт для засечек
public static Double f1(double x)
{
double LB = 0.1;
return LB * Math.Exp(-LB * x);
}
public static Double f2(double x)
{
double LB = 0.05;
return LB * Math.Exp(-LB * x);
}
public static Double f3(double x)
{
double A = 1, B = 29;
if (x >= A && x <= B) return ((double)1 / (B - A));
else return 0;
}
public static Double f4(double x)
{
double C = 2, D = 18;
if (x >= C && x <= D) return ((double)2 / (D - C)) - 2 * System.Math.Abs(C + D - 2 * x) / ((double)(D - C) * (D - C));
else return 0;
}
public static Double f5(double x)
{
double Q = 2, M = 16;
return Math.Exp(-Math.Pow(x - M, 2) / (2 * Math.Pow(Q, 2))) / (Q * Math.Sqrt(2 * Math.PI));
}
public static Double f6(double x)
{
double Q = 2, M = 12;
return Math.Exp(-Math.Pow(x - M, 2) / (2 * Math.Pow(Q, 2))) / Q * Math.Sqrt(2 * Math.PI);
}
public static Double f6_1(double x)
{
double Q = 2, M = 12;
return Math.Exp((-(x - M) * (x - M)) / (2 * Q * Q)) / (Q * Math.Sqrt(2 * Math.PI));
}
public static Double f7(double x)
{
double A = 2, B = 14;
if (x >= A && x <= B) return ((double)1 / (B - A));
else return 0;
}
public static Double g(double x)
{
double summ = 0; int k = 0;
summ = 0.00000020 * Math.Pow(x, 5) + 0.00001886 * Math.Pow(x, 4) + -0.00103821 * Math.Pow(x, 3) + 0.01347689 * Math.Pow(x, 2) + -0.09263277 * x + 1.09571003;
if (summ > 1) summ = 1;
if (summ < 0 || (summ > 0 && x > 20)) k++;
if (k > 0) return 0;
else return summ;
}
double matrixopred(long n, double[,] X)
{
long k, l;
double[,] A = new double[50, 50];
double[,] B = new double[50, 50];
if (n == 2)
{
return X[1, 1] * X[2, 2] - X[1, 2] * X[2, 1];
}
else
{
for (k = 1; k <= n; k++)
for (l = 1; l <= n; l++)
A[k, l] = X[k, l];
if (A[1, 1] == 0)
for (k = 1; k <= n; k++)
A[1, k] = X[1, k] + X[2, k];
for (l = 1; l <= n; l++)
for (k = 2; k <= n; k++)
A[k, l] = A[k, l] - A[1, l] * X[k, 1] / (double)A[1, 1];
for (k = 2; k <= n; k++)
for (l = 2; l <= n; l++)
B[k - 1, l - 1] = A[k, l];
return A[1, 1] * matrixopred(n - 1, B);
}
}
//Процедура Extrem() рассчитывает масштаб и смещение по каждой оси
private void Extrem()
{
mx = (d - ax1) / (xmax - xmin); //Масштаб по оси Х
my = (c - ay1) / (ymin - ymax); //Масштаб по оси Y
//Смещение по оси Х в пикселях
sx = ax1 - Convert.ToInt32(mx * xmin);
//Смещение по оси Y в пикселях
sy = ay1 - Convert.ToInt32(my * ymax);
}
// Процедура grid_x рисует линии сетки по оси X
private void grid_x(Graphics Graph)
{
double x; int i, n;
x = xmin; n = Convert.ToInt32((xmax - xmin) / hx) + 1;
for (i = 0; i <= n; i++)
{
Graph.DrawLine(pn1, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32(ymin * my) + sy,
Convert.ToInt32(x * mx) + sx,
Convert.ToInt32(ymax * my) + sy);
x += hx;
}
}
//Процедура grid _y рисует линии сетки по оси Y
private void grid_y(Graphics Graph)
{
double y; int i, n;
y = ymin;
n = Convert.ToInt32((ymax - ymin) / hy) + 1;
for (i = 1; i <= n; i++)
{
Graph.DrawLine(pn1, Convert.ToInt32(xmin * mx) + sx,
Convert.ToInt32(y * my) + sy,
Convert.ToInt32(xmax * mx) + sx,
Convert.ToInt32(y * my) + sy); y += hy;
}
}
//Процедура axis_x() рисует и подписывает ось X
private void axis_x(Graphics Graph)
{
Graph.DrawLine(pn2, Convert.ToInt32(xmin * mx) + sx, sy, Convert.ToInt32(xmax * mx) + sx, sy);
Graph.DrawString("Х", fn, Brushes.Black, Convert.ToInt32(xmax * mx) + sx + 10, sy);
}
//Процедура axis_y() рисует и подписывает ось Y
private void axis_y(Graphics Graph)
{
Graph.DrawLine(pn2, sx, Convert.ToInt32(ymin * my) + sy, sx, Convert.ToInt32(ymax * my) + sy);
Graph.DrawString("Y", fn, Brushes.Black, sx - 15, Convert.ToInt32(ymax * my) + sy);
}
//Процедура z_x рисует и подписывает засечки по оси X
private void z_x(Graphics Graph)
{
for (double i = xmin; i <= xmax; i += hx)
{
Graph.DrawLine(pn2, Convert.ToInt32(i * mx) + sx, sy, Convert.ToInt32(i * mx) + sx, 5 + sy);
Graph.DrawString(Convert.ToString(i), fn1, Brushes.Black, Convert.ToInt32(i * mx) + sx - 8, 5 + sy);
}
}
//Процедура z_y рисует и подписывает засечки по оси y
private void z_y(Graphics Graph)
{
for (double i = ymin; i <= ymax; i += hy)
{
Graph.DrawLine(pn2, sx, Convert.ToInt32(i * my) + sy, 5 + sx, Convert.ToInt32(i * my) + sy);
if (i != 0) Graph.DrawString(Convert.ToString(i), fn1, Brushes.Black, sx + 5, Convert.ToInt32(i * my) + sy);
}
}
private void Rasmetka(PictureBox picBox, Graphics Graph)
{
ax1 = 10; ay1 = 10; ax2 = 20; ay2 = 20;
//Высота в пикселях будущего графика
c = picBox.Size.Height - ay1 - ay2;
//Ширина в пикселях будущего графика
d = picBox.Size.Width - ax1 - ax2;
Extrem(); //Вычисление масштаба и смещения по осям
//Шаг по засечкам по оси x
hx = 1;
//Шаг по засечкам по оси y
hy = 0.1;
grid_x(Graph); //Прорисовка линий сетки по оси X
grid_y(Graph); //Прорисовка линий сетки по оси Y
axis_x(Graph); //Прорисовка и подпись оси X
axis_y(Graph); //Прорисовка и подпись оси Y
//Прорисовка засечек и подписей по оси x и по оси y
z_x(Graph); z_y(Graph);
}
private void toolStripMenuItem1_Click(object sender, EventArgs e)
{
groupBox2.Visible = false;
groupBox3.Visible = false;
groupBox4.Visible = false;
groupBox1.Visible = true;
groupBox1.Location = new System.Drawing.Point(12, 30);
groupBox1.Size = new System.Drawing.Size(711, 480);
}
private void функцииБлоковToolStripMenuItem_Click(object sender, EventArgs e)
{
groupBox2.Visible = true;
groupBox1.Visible = false;
groupBox3.Visible = false;
groupBox4.Visible = false;
groupBox2.Location = new System.Drawing.Point(12, 30);
groupBox2.Size = new System.Drawing.Size(689, 452);
}
private void распределениеБлоковToolStripMenuItem_Click(object sender, EventArgs e)
{
groupBox4.Visible = true;
groupBox1.Visible = false;
groupBox3.Visible = false;
groupBox2.Visible = false;
groupBox4.Location = new System.Drawing.Point(12, 30);
groupBox4.Size = new System.Drawing.Size(700, 452);
}
private void функцииСистемыToolStripMenuItem_Click(object sender, EventArgs e)
{
groupBox2.Visible = false;
groupBox1.Visible = false;
groupBox4.Visible = false;
groupBox3.Visible = true;
groupBox3.Location = new System.Drawing.Point(12, 30);
groupBox3.Size = new System.Drawing.Size(717, 500);
}
private void button1_Click(object sender, EventArgs e)
{
label6.Text = "Текущая функция: f(x) = e^(-x/10)/10";
double h;
Graphics Graph = pictureBox4.CreateGraphics();
pictureBox4.Refresh();
xmin = 0; xmax = 30;
ymin = 0; ymax = 0.2;
Rasmetka(pictureBox4, Graph);
h = 0.001;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pn, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32(f1(x) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32(f1(x + h) * my) + sy);
}
private void button2_Click(object sender, EventArgs e)
{
label6.Text = "Текущая функция: f(x) = e^(-x/20)/20";
double h;
Graphics Graph = pictureBox4.CreateGraphics();
pictureBox4.Refresh();
xmin = 0; xmax = 30;
ymin = 0; ymax = 0.1;
Rasmetka(pictureBox4, Graph);
h = 0.001;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pn, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32(f2(x) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32(f2(x + h) * my) + sy);
}
private void button3_Click(object sender, EventArgs e)
{
label6.Text = "Текущая функция: f(x) = 1/28";
double h;
Graphics Graph = pictureBox4.CreateGraphics();
pictureBox4.Refresh();
xmin = 0; xmax = 30;
ymin = 0; ymax = 0.1;
Rasmetka(pictureBox4, Graph);
h = 0.001;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pn, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32(f3(x) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32(f3(x + h) * my) + sy);
}
private void button4_Click(object sender, EventArgs e)
{
label6.Text = "Текущая функция: f(x) = 1/8-|20-2x|/128";
double h;
Graphics Graph = pictureBox4.CreateGraphics();
pictureBox4.Refresh();
xmin = 0; xmax = 30;
ymin = 0; ymax = 0.2;
Rasmetka(pictureBox4, Graph);
h = 0.0001;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pn, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32(f4(x) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32(f4(x + h) * my) + sy);
}
private void button5_Click(object sender, EventArgs e)
{
label6.Text = "Текущая функция: f(x) = e^((x-16)^2/8)/2*(2*pi)^0,5";
double h;
Graphics Graph = pictureBox4.CreateGraphics();
pictureBox4.Refresh();
xmin = 0; xmax = 30;
ymin = 0; ymax = 0.4;
Rasmetka(pictureBox4, Graph);
h = 0.001;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pn, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32(f5(x) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32(f5(x + h) * my) + sy);
}
private void button6_Click(object sender, EventArgs e)
{
label6.Text = "Текущая функция: f(x) = e^((x-12)^2/8)/2*(2*pi)^0,5";
double h;
Graphics Graph = pictureBox4.CreateGraphics();
pictureBox4.Refresh();
xmin = 0; xmax = 30;
ymin = 0; ymax = 1.3;
Rasmetka(pictureBox4, Graph);
h = 0.001;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pn, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32(f6(x) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32(f6(x + h) * my) + sy);
}
private void button7_Click(object sender, EventArgs e)
{
label6.Text = "Текущая функция: f(x) = 1/12";
double h;
Graphics Graph = pictureBox4.CreateGraphics();
pictureBox4.Refresh();
xmin = 0; xmax = 30;
ymin = 0; ymax = 0.1;
Rasmetka(pictureBox4, Graph);
h = 0.001;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pn, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32(f7(x) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32(f7(x + h) * my) + sy);
}
/// <summary>
/// Интегрирование методом Симпсона
/// </summary>
/// <param name="k">Номер закона распределния функции</param>
/// <param name="a">Начало интервала</param>
/// <param name="b">Конец интервала</param>
/// <param name="n">Количество участков</param>
/// <returns></returns>
public static Double Integrate(double a, double b, int k)
{
double sum = 0;
long n = 8000;
double h = (b - a) / n;
double x = a + h;
switch (k)
{
case 1:
while (x < b)
{
sum += 4 * f1(x); x += h;
sum += 2 * f1(x); x += h;
}
sum = (h / 3) * (sum + f1(a) - f1(b));
break;
case 2:
while (x < b)
{
sum += 4 * f2(x); x += h;
sum += 2 * f2(x); x += h;
}
sum = (h / 3) * (sum + f2(a) - f2(b));
break;
case 3:
while (x < b)
{
sum += 4 * f3(x); x += h;
sum += 2 * f3(x); x += h;
}
sum = (h / 3) * (sum + f3(a) - f3(b));
break;
case 4:
while (x < b)
{
sum += 4 * f4(x); x += h;
sum += 2 * f4(x); x += h;
}
sum = (h / 3) * (sum + f4(a) - f4(b));
break;
case 5:
while (x < b)
{
sum += 4 * f5(x); x += h;
sum += 2 * f5(x); x += h;
}
sum = (h / 3) * (sum + f5(a) - f5(b));
break;
case 6:
while (x < b)
{
sum += 4 * f6(x); x += h;
sum += 2 * f6(x); x += h;
}
sum = (h / 3) * (sum + f6(a) - f6(b));
break;
case 61:
while (x < b)
{
sum += 4 * f6_1(x); x += h;
sum += 2 * f6_1(x); x += h;
}
sum = (h / 3) * (sum + f6_1(a) - f6_1(b));
break;
case 7:
while (x < b)
{
sum += 4 * f7(x); x += h;
sum += 2 * f7(x); x += h;
}
sum = (h / 3) * (sum + f7(a) - f7(b));
break;
}
return sum;
}
static double psr;
static int t0, tn;
//Вычисление вероятности безотказной работы системы заданное время t
public static Double Pintg(Int32 t)
{
double N = 60000, k = 0, one = 1;
long unbt = 0, count = 0;
double y11, y21, y31, y41, y51, y61, y71, y12, y22, y32, y42, y52, y62, y72;
Random rnd = new Random(DateTime.Now.Millisecond);
y12 = Integrate(0, t, 1);
y22 = Integrate(0, t, 2);
y32 = Integrate(0, t, 3);
y42 = Integrate(0, t, 4);
y52 = Integrate(0, t, 5);
y62 = Integrate(0, t, 6);
y72 = Integrate(0, t, 7);
for (int i = 1; i < N; i++)
{
y11 = rnd.NextDouble();
y21 = rnd.NextDouble();
y31 = rnd.NextDouble();
y41 = rnd.NextDouble();
y51 = rnd.NextDouble();
y61 = rnd.NextDouble();
y71 = rnd.NextDouble();
if (y11 <= y12 || (y21 <= y22 && ((y31 <= y32 && y61 <= y62) || (y41 <= y42 && y51 <= y52 && y71 <= y72))))
//if (y11 <= y12 && (y21 <= y22 || ((y31 <= y32 || y61 <= y62) && (y41 <= y42 || y51 <= y52 || y71 <= y72))))
{ k++; count++; }
else { unbt += count; count = 0; }
}
KParr[t] = unbt;
return one - k / N;
}
double AverTime()
{
double c = 0, N = 60000;
for (long i = t0; i <= tn; i++) c += N - KParr[i];
return (double)c / N;
}
double _opred, _a, _b, _c, _d, _e, _f, _xtil1, _xtil0;
double approx(double x)
{
if (x < _xtil1) return 1;
else if (x < _xtil0) return System.Math.Pow(x, 5) * _a + System.Math.Pow(x, 4) * _b +
System.Math.Pow(x, 3) * _c + System.Math.Pow(x, 2) * _d + System.Math.Pow(x, 1) * _e + _f;
else return 0;
}
static int kolParr;
//Построение закона распределения, вычиление членов для метода наименьших квадратов
private void button8_Click(object sender, EventArgs e)
{
int i;
for (i = 0; i < 200; i++) Parr[i] = 0;
for (i = 0; i < 200; i++) KParr[i] = 0;
double c = 1;
i = 0;
while (c > 0.000017)
{
c = Math.Round(Pintg(i), 8);
Parr[i] = c;
i++;
}
Graphics Graph = pictureBox5.CreateGraphics();
Graph.Clear(pictureBox1.BackColor);
pictureBox5.Refresh();
Pen backpen = new Pen(Color.Green);
Brush fontbrush = Brushes.Black;
Font backfont = new Font("Arial", 8);
Point moveto1 = new Point(15, 15);
Point lineto1 = new Point(15, pictureBox5.Height - 15);
Point strto1 = new Point(12, pictureBox5.Height - 12);
for (long k = 0; k < 40; k++)
{
Graph.DrawLine(backpen, moveto1, lineto1);
moveto1.X = 15 + (int)(((k + 1) * pictureBox5.Width - 15) / (40 + 1));
lineto1.X = moveto1.X;
Graph.DrawString(k.ToString(), backfont, fontbrush, strto1);
strto1.X = 12 + (int)(((k + 1) * pictureBox5.Width - 15) / (40 + 1));
}
Point moveto2 = new Point(15, 15);
Point lineto2 = new Point(15 + (int)(40 * (pictureBox5.Width - 15) / (40 + 1)), 15);
Point strto2 = new Point(2, 7);
for (long k = 0; k <= 10; k++)
{
Graph.DrawLine(backpen, moveto2, lineto2);
moveto2.Y = 15 + (int)((pictureBox5.Height - 30) * (k + 1) / 10);
lineto2.Y = moveto2.Y;
Graph.DrawString((1 - k * 0.1).ToString(), backfont, fontbrush, strto2);
strto2.Y = 7 + (int)((pictureBox5.Height - 30) * (k + 1) / 10);
}
Pen Graphpen = new Pen(Color.Blue, 2);
Brush brGraph = Brushes.Purple;
Point moveto3 = new Point(15, pictureBox5.Height - (int)(15 + (pictureBox5.Height - 30) * Parr[0]));
Point lineto3 = new Point(15 + (int)((pictureBox5.Width - 15) / (40 + 1)), pictureBox5.Height - (int)(15 + (pictureBox5.Height - 30) * Parr[1]));
for (long k = 1; k < 40; k++)
{
Graph.DrawLine(Graphpen, moveto3, lineto3);
Graph.DrawEllipse(Graphpen, moveto3.X - 2, moveto3.Y - 2, 4, 4);
moveto3.X = lineto3.X;
moveto3.Y = lineto3.Y;
lineto3.X = 15 + (int)(((k + 1) * pictureBox5.Width - 15) / (40 + 1));
lineto3.Y = pictureBox5.Height - (int)(15 + (pictureBox5.Height - 30) * Parr[k + 1]);
}
textBox1.Text = string.Format("{0}", AverTime());
kolParr = i;
//myAL.Sort();
//PrintValues(myAL, textBox5, myAL.Count-1);
}
//Вывод закона распределения
public static void PrintValues(IEnumerable myList, TextBox T, Int32 i)
{
foreach (Object obj in myList)
{
if (i > 1)
{ T.Text += string.Format("{0}*x^{1} + ", obj, i); i--; }
else if (i == 1) { T.Text += string.Format("{0}*x + ", obj); i--; }
else T.Text += string.Format("{0}", obj);
}
}
//Вероятность работы системы на промежутке времени - psr
//И среднее время безотказной работы системы - srbezot
private void button10_Click(object sender, EventArgs e)
{
t0 = Convert.ToInt32(textBox3.Text);
tn = Convert.ToInt32(textBox4.Text);
if (t0 <= tn) psr = Pintg(tn) / Pintg(t0);
else psr = 0;
textBox2.Text = Convert.ToString(psr);
textBox1.Text = string.Format("{0}", AverTime());
}
double sumxpowk(long a, long n, long k, long l)
{
long i;
double res = 0;
for (i = a; i <= (n - 1); i++)
{
res += (double)System.Math.Pow(i, k) * System.Math.Pow(Parr[i], l);
}
return res;
}
private void button17_Click(object sender, EventArgs e)
{
label12.Text = "Интеграл блока 1: f(x) = e^(-x/10)/10";
double h;
Graphics Graph = pictureBox6.CreateGraphics();
pictureBox6.Refresh();
xmin = 0; xmax = 45;
ymin = 0; ymax = 1;
Rasmetka(pictureBox4, Graph);
h = 0.1;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pen, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32((1 - Integrate(0, x, 1)) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32((1 - Integrate(0, (x + h), 1)) * my) + sy);
}
private void button16_Click(object sender, EventArgs e)
{
label12.Text = "Интеграл блока 2: f(x) = e^(-x/20)/20";
double h;
Graphics Graph = pictureBox6.CreateGraphics();
pictureBox6.Refresh();
xmin = 0; xmax = 45;
ymin = 0; ymax = 1;
Rasmetka(pictureBox4, Graph);
h = 0.1;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pen, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32((1 - Integrate(0, x, 2)) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32((1 - Integrate(0, (x + h), 2)) * my) + sy);
}
private void button15_Click(object sender, EventArgs e)
{
label12.Text = "Интеграл блока 3: f(x) = 1/28";
double h;
Graphics Graph = pictureBox6.CreateGraphics();
pictureBox6.Refresh();
xmin = 0; xmax = 45;
ymin = 0; ymax = 1;
Rasmetka(pictureBox4, Graph);
h = 0.1;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pen, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32((1 - Integrate(0, x, 3)) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32((1 - Integrate(0, (x + h), 3)) * my) + sy);
}
private void button14_Click(object sender, EventArgs e)
{
label12.Text = "Интеграл блока 4: f(x) = 1/8-|20-2x|/128";
double h;
Graphics Graph = pictureBox6.CreateGraphics();
pictureBox6.Refresh();
xmin = 0; xmax = 30;
ymin = 0; ymax = 1;
Rasmetka(pictureBox4, Graph);
h = 0.1;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pen, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32((1 - Integrate(0, x, 4)) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32((1 - Integrate(0, (x + h), 4)) * my) + sy);
}
private void button13_Click(object sender, EventArgs e)
{
label12.Text = "Интеграл блока 5: f(x) = e^((x-16)^2/8)/2*(2*pi)^0,5";
double h;
Graphics Graph = pictureBox6.CreateGraphics();
pictureBox6.Refresh();
xmin = 0; xmax = 30;
ymin = 0; ymax = 1;
Rasmetka(pictureBox4, Graph);
h = 0.1;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pen, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32((1 - Integrate(0, x, 5)) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32((1 - Integrate(0, (x + h), 5)) * my) + sy);
}
private void button12_Click(object sender, EventArgs e)
{
label12.Text = "Интеграл блока 6: f(x) = e^((x-12)^2/8)/2*(2*pi)^0,5";
double h;
Graphics Graph = pictureBox6.CreateGraphics();
pictureBox6.Refresh();
xmin = 0; xmax = 30;
ymin = 0; ymax = 1;
Rasmetka(pictureBox4, Graph);
h = 0.1;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pen, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32((1 - Integrate(0, x, 61)) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32((1 - Integrate(0, (x + h), 61)) * my) + sy);
}
private void button11_Click(object sender, EventArgs e)
{
label12.Text = "Интеграл блока 7: f(x) = 1/12";
double h;
Graphics Graph = pictureBox6.CreateGraphics();
pictureBox6.Refresh();
xmin = 0; xmax = 30;
ymin = 0; ymax = 1;
Rasmetka(pictureBox4, Graph);
h = 0.1;
for (double x = xmin; x <= xmax; x += h)
Graph.DrawLine(pen, Convert.ToInt32(x * mx) + sx,
Convert.ToInt32((1 - Integrate(0, x, 7)) * my) + sy,
Convert.ToInt32((x + h) * mx) + sx,
Convert.ToInt32((1 - Integrate(0, (x + h), 7)) * my) + sy);
}
private void button9_Click(object sender, EventArgs e)
{
textBox5.Clear();
long k, i, amax = 0, bmin = kolParr;
double ii;
i = amax;
do
{ i++; }
while (Parr[i] >= 1);
if (i > 0) amax = i - 1;
else amax = i;
i = bmin;
do
{ i--; }
while (Parr[i] <= 0.000017);
if (i < kolParr) bmin = i + 1;
else bmin = i;
MATR[1, 1] = sumxpowk(amax, bmin, 10, 0); MATR[1, 2] = sumxpowk(amax, bmin, 9, 0); MATR[1, 3] = sumxpowk(amax, bmin, 8, 0); MATR[1, 4] = sumxpowk(amax, bmin, 7, 0); MATR[1, 5] = sumxpowk(amax, bmin, 6, 0); MATR[1, 6] = sumxpowk(amax, bmin, 5, 0);
MATR[2, 1] = sumxpowk(amax, bmin, 9, 0); MATR[2, 2] = sumxpowk(amax, bmin, 8, 0); MATR[2, 3] = sumxpowk(amax, bmin, 7, 0); MATR[2, 4] = sumxpowk(amax, bmin, 6, 0); MATR[2, 5] = sumxpowk(amax, bmin, 5, 0); MATR[2, 6] = sumxpowk(amax, bmin, 4, 0);
MATR[3, 1] = sumxpowk(amax, bmin, 8, 0); MATR[3, 2] = sumxpowk(amax, bmin, 7, 0); MATR[3, 3] = sumxpowk(amax, bmin, 6, 0); MATR[3, 4] = sumxpowk(amax, bmin, 5, 0); MATR[3, 5] = sumxpowk(amax, bmin, 4, 0); MATR[3, 6] = sumxpowk(amax, bmin, 3, 0);
MATR[4, 1] = sumxpowk(amax, bmin, 7, 0); MATR[4, 2] = sumxpowk(amax, bmin, 6, 0); MATR[4, 3] = sumxpowk(amax, bmin, 5, 0); MATR[4, 4] = sumxpowk(amax, bmin, 4, 0); MATR[4, 5] = sumxpowk(amax, bmin, 3, 0); MATR[4, 6] = sumxpowk(amax, bmin, 2, 0);
MATR[5, 1] = sumxpowk(amax, bmin, 6, 0); MATR[5, 2] = sumxpowk(amax, bmin, 5, 0); MATR[5, 3] = sumxpowk(amax, bmin, 4, 0); MATR[5, 4] = sumxpowk(amax, bmin, 3, 0); MATR[5, 5] = sumxpowk(amax, bmin, 2, 0); MATR[5, 6] = sumxpowk(amax, bmin, 1, 0);
MATR[6, 1] = sumxpowk(amax, bmin, 5, 0); MATR[6, 2] = sumxpowk(amax, bmin, 4, 0); MATR[6, 3] = sumxpowk(amax, bmin, 3, 0); MATR[6, 4] = sumxpowk(amax, bmin, 2, 0); MATR[6, 5] = sumxpowk(amax, bmin, 1, 0); MATR[6, 6] = sumxpowk(amax, bmin, 0, 0);
_opred = matrixopred(6, MATR); //определитель исходной матрицы
MATR[1, 1] = sumxpowk(amax, bmin, 5, 1); MATR[1, 2] = sumxpowk(amax, bmin, 9, 0); MATR[1, 3] = sumxpowk(amax, bmin, 8, 0); MATR[1, 4] = sumxpowk(amax, bmin, 7, 0); MATR[1, 5] = sumxpowk(amax, bmin, 6, 0); MATR[1, 6] = sumxpowk(amax, bmin, 5, 0);
MATR[2, 1] = sumxpowk(amax, bmin, 4, 1); MATR[2, 2] = sumxpowk(amax, bmin, 8, 0); MATR[2, 3] = sumxpowk(amax, bmin, 7, 0); MATR[2, 4] = sumxpowk(amax, bmin, 6, 0); MATR[2, 5] = sumxpowk(amax, bmin, 5, 0); MATR[2, 6] = sumxpowk(amax, bmin, 4, 0);
MATR[3, 1] = sumxpowk(amax, bmin, 3, 1); MATR[3, 2] = sumxpowk(amax, bmin, 7, 0); MATR[3, 3] = sumxpowk(amax, bmin, 6, 0); MATR[3, 4] = sumxpowk(amax, bmin, 5, 0); MATR[3, 5] = sumxpowk(amax, bmin, 4, 0); MATR[3, 6] = sumxpowk(amax, bmin, 3, 0);
MATR[4, 1] = sumxpowk(amax, bmin, 2, 1); MATR[4, 2] = sumxpowk(amax, bmin, 6, 0); MATR[4, 3] = sumxpowk(amax, bmin, 5, 0); MATR[4, 4] = sumxpowk(amax, bmin, 4, 0); MATR[4, 5] = sumxpowk(amax, bmin, 3, 0); MATR[4, 6] = sumxpowk(amax, bmin, 2, 0);
MATR[5, 1] = sumxpowk(amax, bmin, 1, 1); MATR[5, 2] = sumxpowk(amax, bmin, 5, 0); MATR[5, 3] = sumxpowk(amax, bmin, 4, 0); MATR[5, 4] = sumxpowk(amax, bmin, 3, 0); MATR[5, 5] = sumxpowk(amax, bmin, 2, 0); MATR[5, 6] = sumxpowk(amax, bmin, 1, 0);
MATR[6, 1] = sumxpowk(amax, bmin, 0, 1); MATR[6, 2] = sumxpowk(amax, bmin, 4, 0); MATR[6, 3] = sumxpowk(amax, bmin, 3, 0); MATR[6, 4] = sumxpowk(amax, bmin, 2, 0); MATR[6, 5] = sumxpowk(amax, bmin, 1, 0); MATR[6, 6] = sumxpowk(amax, bmin, 0, 0);
_a = matrixopred(6, MATR) / _opred; //определитель матрицы со значениями y в столбце 1
MATR[1, 1] = sumxpowk(amax, bmin, 10, 0); MATR[1, 2] = sumxpowk(amax, bmin, 5, 1); MATR[1, 3] = sumxpowk(amax, bmin, 8, 0); MATR[1, 4] = sumxpowk(amax, bmin, 7, 0); MATR[1, 5] = sumxpowk(amax, bmin, 6, 0); MATR[1, 6] = sumxpowk(amax, bmin, 5, 0);
MATR[2, 1] = sumxpowk(amax, bmin, 9, 0); MATR[2, 2] = sumxpowk(amax, bmin, 4, 1); MATR[2, 3] = sumxpowk(amax, bmin, 7, 0); MATR[2, 4] = sumxpowk(amax, bmin, 6, 0); MATR[2, 5] = sumxpowk(amax, bmin, 5, 0); MATR[2, 6] = sumxpowk(amax, bmin, 4, 0);
MATR[3, 1] = sumxpowk(amax, bmin, 8, 0); MATR[3, 2] = sumxpowk(amax, bmin, 3, 1); MATR[3, 3] = sumxpowk(amax, bmin, 6, 0); MATR[3, 4] = sumxpowk(amax, bmin, 5, 0); MATR[3, 5] = sumxpowk(amax, bmin, 4, 0); MATR[3, 6] = sumxpowk(amax, bmin, 3, 0);
MATR[4, 1] = sumxpowk(amax, bmin, 7, 0); MATR[4, 2] = sumxpowk(amax, bmin, 2, 1); MATR[4, 3] = sumxpowk(amax, bmin, 5, 0); MATR[4, 4] = sumxpowk(amax, bmin, 4, 0); MATR[4, 5] = sumxpowk(amax, bmin, 3, 0); MATR[4, 6] = sumxpowk(amax, bmin, 2, 0);
MATR[5, 1] = sumxpowk(amax, bmin, 6, 0); MATR[5, 2] = sumxpowk(amax, bmin, 1, 1); MATR[5, 3] = sumxpowk(amax, bmin, 4, 0); MATR[5, 4] = sumxpowk(amax, bmin, 3, 0); MATR[5, 5] = sumxpowk(amax, bmin, 2, 0); MATR[5, 6] = sumxpowk(amax, bmin, 1, 0);
MATR[6, 1] = sumxpowk(amax, bmin, 5, 0); MATR[6, 2] = sumxpowk(amax, bmin, 0, 1); MATR[6, 3] = sumxpowk(amax, bmin, 3, 0); MATR[6, 4] = sumxpowk(amax, bmin, 2, 0); MATR[6, 5] = sumxpowk(amax, bmin, 1, 0); MATR[6, 6] = sumxpowk(amax, bmin, 0, 0);
_b = matrixopred(6, MATR) / _opred; //определитель матрицы со значениями y в столбце 2
MATR[1, 1] = sumxpowk(amax, bmin, 10, 0); MATR[1, 2] = sumxpowk(amax, bmin, 9, 0); MATR[1, 3] = sumxpowk(amax, bmin, 5, 1); MATR[1, 4] = sumxpowk(amax, bmin, 7, 0); MATR[1, 5] = sumxpowk(amax, bmin, 6, 0); MATR[1, 6] = sumxpowk(amax, bmin, 5, 0);
MATR[2, 1] = sumxpowk(amax, bmin, 9, 0); MATR[2, 2] = sumxpowk(amax, bmin, 8, 0); MATR[2, 3] = sumxpowk(amax, bmin, 4, 1); MATR[2, 4] = sumxpowk(amax, bmin, 6, 0); MATR[2, 5] = sumxpowk(amax, bmin, 5, 0); MATR[2, 6] = sumxpowk(amax, bmin, 4, 0);
MATR[3, 1] = sumxpowk(amax, bmin, 8, 0); MATR[3, 2] = sumxpowk(amax, bmin, 7, 0); MATR[3, 3] = sumxpowk(amax, bmin, 3, 1); MATR[3, 4] = sumxpowk(amax, bmin, 5, 0); MATR[3, 5] = sumxpowk(amax, bmin, 4, 0); MATR[3, 6] = sumxpowk(amax, bmin, 3, 0);
MATR[4, 1] = sumxpowk(amax, bmin, 7, 0); MATR[4, 2] = sumxpowk(amax, bmin, 6, 0); MATR[4, 3] = sumxpowk(amax, bmin, 2, 1); MATR[4, 4] = sumxpowk(amax, bmin, 4, 0); MATR[4, 5] = sumxpowk(amax, bmin, 3, 0); MATR[4, 6] = sumxpowk(amax, bmin, 2, 0);
MATR[5, 1] = sumxpowk(amax, bmin, 6, 0); MATR[5, 2] = sumxpowk(amax, bmin, 5, 0); MATR[5, 3] = sumxpowk(amax, bmin, 1, 1); MATR[5, 4] = sumxpowk(amax, bmin, 3, 0); MATR[5, 5] = sumxpowk(amax, bmin, 2, 0); MATR[5, 6] = sumxpowk(amax, bmin, 1, 0);
MATR[6, 1] = sumxpowk(amax, bmin, 5, 0); MATR[6, 2] = sumxpowk(amax, bmin, 4, 0); MATR[6, 3] = sumxpowk(amax, bmin, 0, 1); MATR[6, 4] = sumxpowk(amax, bmin, 2, 0); MATR[6, 5] = sumxpowk(amax, bmin, 1, 0); MATR[6, 6] = sumxpowk(amax, bmin, 0, 0);
_c = matrixopred(6, MATR) / _opred; //определитель матрицы со значениями y в столбце 3
MATR[1, 1] = sumxpowk(amax, bmin, 10, 0); MATR[1, 2] = sumxpowk(amax, bmin, 9, 0); MATR[1, 3] = sumxpowk(amax, bmin, 8, 0); MATR[1, 4] = sumxpowk(amax, bmin, 5, 1); MATR[1, 5] = sumxpowk(amax, bmin, 6, 0); MATR[1, 6] = sumxpowk(amax, bmin, 5, 0);
MATR[2, 1] = sumxpowk(amax, bmin, 9, 0); MATR[2, 2] = sumxpowk(amax, bmin, 8, 0); MATR[2, 3] = sumxpowk(amax, bmin, 7, 0); MATR[2, 4] = sumxpowk(amax, bmin, 4, 1); MATR[2, 5] = sumxpowk(amax, bmin, 5, 0); MATR[2, 6] = sumxpowk(amax, bmin, 4, 0);
MATR[3, 1] = sumxpowk(amax, bmin, 8, 0); MATR[3, 2] = sumxpowk(amax, bmin, 7, 0); MATR[3, 3] = sumxpowk(amax, bmin, 6, 0); MATR[3, 4] = sumxpowk(amax, bmin, 3, 1); MATR[3, 5] = sumxpowk(amax, bmin, 4, 0); MATR[3, 6] = sumxpowk(amax, bmin, 3, 0);
MATR[4, 1] = sumxpowk(amax, bmin, 7, 0); MATR[4, 2] = sumxpowk(amax, bmin, 6, 0); MATR[4, 3] = sumxpowk(amax, bmin, 5, 0); MATR[4, 4] = sumxpowk(amax, bmin, 2, 1); MATR[4, 5] = sumxpowk(amax, bmin, 3, 0); MATR[4, 6] = sumxpowk(amax, bmin, 2, 0);
MATR[5, 1] = sumxpowk(amax, bmin, 6, 0); MATR[5, 2] = sumxpowk(amax, bmin, 5, 0); MATR[5, 3] = sumxpowk(amax, bmin, 4, 0); MATR[5, 4] = sumxpowk(amax, bmin, 1, 1); MATR[5, 5] = sumxpowk(amax, bmin, 2, 0); MATR[5, 6] = sumxpowk(amax, bmin, 1, 0);
MATR[6, 1] = sumxpowk(amax, bmin, 5, 0); MATR[6, 2] = sumxpowk(amax, bmin, 4, 0); MATR[6, 3] = sumxpowk(amax, bmin, 3, 0); MATR[6, 4] = sumxpowk(amax, bmin, 0, 1); MATR[6, 5] = sumxpowk(amax, bmin, 1, 0); MATR[6, 6] = sumxpowk(amax, bmin, 0, 0);
_d = matrixopred(6, MATR) / _opred; //определитель матрицы со значениями y в столбце 4
MATR[1, 1] = sumxpowk(amax, bmin, 10, 0); MATR[1, 2] = sumxpowk(amax, bmin, 9, 0); MATR[1, 3] = sumxpowk(amax, bmin, 8, 0); MATR[1, 4] = sumxpowk(amax, bmin, 7, 0); MATR[1, 5] = sumxpowk(amax, bmin, 5, 1); MATR[1, 6] = sumxpowk(amax, bmin, 5, 0);
MATR[2, 1] = sumxpowk(amax, bmin, 9, 0); MATR[2, 2] = sumxpowk(amax, bmin, 8, 0); MATR[2, 3] = sumxpowk(amax, bmin, 7, 0); MATR[2, 4] = sumxpowk(amax, bmin, 6, 0); MATR[2, 5] = sumxpowk(amax, bmin, 4, 1); MATR[2, 6] = sumxpowk(amax, bmin, 4, 0);
MATR[3, 1] = sumxpowk(amax, bmin, 8, 0); MATR[3, 2] = sumxpowk(amax, bmin, 7, 0); MATR[3, 3] = sumxpowk(amax, bmin, 6, 0); MATR[3, 4] = sumxpowk(amax, bmin, 5, 0); MATR[3, 5] = sumxpowk(amax, bmin, 3, 1); MATR[3, 6] = sumxpowk(amax, bmin, 3, 0);
MATR[4, 1] = sumxpowk(amax, bmin, 7, 0); MATR[4, 2] = sumxpowk(amax, bmin, 6, 0); MATR[4, 3] = sumxpowk(amax, bmin, 5, 0); MATR[4, 4] = sumxpowk(amax, bmin, 4, 0); MATR[4, 5] = sumxpowk(amax, bmin, 2, 1); MATR[4, 6] = sumxpowk(amax, bmin, 2, 0);
MATR[5, 1] = sumxpowk(amax, bmin, 6, 0); MATR[5, 2] = sumxpowk(amax, bmin, 5, 0); MATR[5, 3] = sumxpowk(amax, bmin, 4, 0); MATR[5, 4] = sumxpowk(amax, bmin, 3, 0); MATR[5, 5] = sumxpowk(amax, bmin, 1, 1); MATR[5, 6] = sumxpowk(amax, bmin, 1, 0);
MATR[6, 1] = sumxpowk(amax, bmin, 5, 0); MATR[6, 2] = sumxpowk(amax, bmin, 4, 0); MATR[6, 3] = sumxpowk(amax, bmin, 3, 0); MATR[6, 4] = sumxpowk(amax, bmin, 2, 0); MATR[6, 5] = sumxpowk(amax, bmin, 0, 1); MATR[6, 6] = sumxpowk(amax, bmin, 0, 0);
_e = matrixopred(6, MATR) / _opred; //определитель матрицы со значениями y в столбце 5
MATR[1, 1] = sumxpowk(amax, bmin, 10, 0); MATR[1, 2] = sumxpowk(amax, bmin, 9, 0); MATR[1, 3] = sumxpowk(amax, bmin, 8, 0); MATR[1, 4] = sumxpowk(amax, bmin, 7, 0); MATR[1, 5] = sumxpowk(amax, bmin, 6, 0); MATR[1, 6] = sumxpowk(amax, bmin, 5, 1);
MATR[2, 1] = sumxpowk(amax, bmin, 9, 0); MATR[2, 2] = sumxpowk(amax, bmin, 8, 0); MATR[2, 3] = sumxpowk(amax, bmin, 7, 0); MATR[2, 4] = sumxpowk(amax, bmin, 6, 0); MATR[2, 5] = sumxpowk(amax, bmin, 5, 0); MATR[2, 6] = sumxpowk(amax, bmin, 4, 1);
MATR[3, 1] = sumxpowk(amax, bmin, 8, 0); MATR[3, 2] = sumxpowk(amax, bmin, 7, 0); MATR[3, 3] = sumxpowk(amax, bmin, 6, 0); MATR[3, 4] = sumxpowk(amax, bmin, 5, 0); MATR[3, 5] = sumxpowk(amax, bmin, 4, 0); MATR[3, 6] = sumxpowk(amax, bmin, 3, 1);
MATR[4, 1] = sumxpowk(amax, bmin, 7, 0); MATR[4, 2] = sumxpowk(amax, bmin, 6, 0); MATR[4, 3] = sumxpowk(amax, bmin, 5, 0); MATR[4, 4] = sumxpowk(amax, bmin, 4, 0); MATR[4, 5] = sumxpowk(amax, bmin, 3, 0); MATR[4, 6] = sumxpowk(amax, bmin, 2, 1);
MATR[5, 1] = sumxpowk(amax, bmin, 6, 0); MATR[5, 2] = sumxpowk(amax, bmin, 5, 0); MATR[5, 3] = sumxpowk(amax, bmin, 4, 0); MATR[5, 4] = sumxpowk(amax, bmin, 3, 0); MATR[5, 5] = sumxpowk(amax, bmin, 2, 0); MATR[5, 6] = sumxpowk(amax, bmin, 1, 1);
MATR[6, 1] = sumxpowk(amax, bmin, 5, 0); MATR[6, 2] = sumxpowk(amax, bmin, 4, 0); MATR[6, 3] = sumxpowk(amax, bmin, 3, 0); MATR[6, 4] = sumxpowk(amax, bmin, 2, 0); MATR[6, 5] = sumxpowk(amax, bmin, 1, 0); MATR[6, 6] = sumxpowk(amax, bmin, 0, 1);
_f = matrixopred(6, MATR) / _opred; //определитель матрицы со значениями y в столбце 6
//создание значений для кусочной функции (1<x<0)
ii = amax;
do ii += 0.01; while (System.Math.Pow(ii, 5) * _a + System.Math.Pow(ii, 4) * _b + System.Math.Pow(ii, 3) * _c + System.Math.Pow(ii, 2) * _d + System.Math.Pow(ii, 1) * _e + _f < 0.988);
_xtil1 = ii;
do ii += 0.01; while (System.Math.Pow(ii, 5) * _a + System.Math.Pow(ii, 4) * _b + System.Math.Pow(ii, 3) * _c + System.Math.Pow(ii, 2) * _d + System.Math.Pow(ii, 1) * _e + _f > 0);
_xtil0 = ii;
Graphics g = pictureBox5.CreateGraphics();
Pen Sglpen = new Pen(Color.Red, 1);
Point moveto4 = new Point(15, pictureBox5.Height - (int)(15 + (pictureBox5.Height - 30) * approx(0)));
Point lineto4 = new Point(15 + (int)((pictureBox5.Width - 15) / (40 + 1)), pictureBox5.Height - (int)(15 + (pictureBox5.Height - 30) * approx(1)));
for (k = 1; k < 40; k++)
{
g.DrawLine(Sglpen, moveto4, lineto4);
g.DrawEllipse(Sglpen, moveto4.X - 2, moveto4.Y - 2, 4, 4);
moveto4.X = lineto4.X;
moveto4.Y = lineto4.Y;
lineto4.X = 15 + (int)(((k + 1) * pictureBox5.Width - 15) / (40 + 1));
lineto4.Y = pictureBox5.Height - (int)(15 + (pictureBox5.Height - 30) * approx(k + 1));
}
textBox5.Text = _a.ToString("0.0000") + "*x^5 + " + _b.ToString("0.0000000") + "*x^4 + " + _c.ToString("0.00000") +
"*x^3 + " + _d.ToString("0.00000") + "*x^2 + " + _e.ToString("0.00000") + "*x^1 + " + _f.ToString("0.00000") +
"; " + _xtil1.ToString("0.00000") + " <= x <= " + _xtil0.ToString("0.00000");
}
}
}
Размещено на Allbest.ru
...Подобные документы
Структура и параметры эффективности функционирования систем массового обслуживания. Процесс имитационного моделирования. Распределения и генераторы псевдослучайных чисел. Описание метода решения задачи вручную. Перевод модели на язык программирования.
курсовая работа [440,4 K], добавлен 30.10.2010Разработка проекта имитационной модели функционирования системы, отдельные элементы которой могут отказывать во время работы. Закон распределения времени безотказной работы всей системы. Вероятность не отказа работы в течении заданного промежутка времени.
курсовая работа [694,9 K], добавлен 04.02.2011Описание задачи линейного целочисленного программирования. Общий алгоритм решения задач с помощью метода границ и ветвей, его сущность и применение для задач календарного планирования. Пример использования метода при решении задачи трех станков.
курсовая работа [728,8 K], добавлен 11.05.2011Характеристика метода Монте-Карло. Его преимущество и недостатки, области применения. Решение задач по оптимизации использования ресурсов, управлению запасами и системе массового обслуживания с помощью средств аналитического и имитационного моделирования.
контрольная работа [1,4 M], добавлен 22.11.2013Оценка влияния разных факторов на среднюю ожидаемую продолжительность жизни по методу наименьших квадратов. Анализ параметров линейной двухфакторной эконометрической модели с помощью метода наименьших квадратов. Графическое изображение данной зависимости.
практическая работа [79,4 K], добавлен 20.10.2015Численные методы решения трансцедентных уравнений. Решение с помощью метода жордановых исключений системы линейных алгебраических уравнений. Симплексный метод решения задачи линейного программирования. Транспортная задача, применение метода потенциалов.
методичка [955,1 K], добавлен 19.06.2015Метод имитационного моделирования, его виды, основные этапы и особенности: статическое и динамическое представление моделируемой системы. Исследование практики использования методов имитационного моделирования в анализе экономических процессов и задач.
курсовая работа [54,3 K], добавлен 26.10.2014Построение математических моделей по определению плана выпуска изделий, обеспечивающего максимальную прибыль, с помощью графического и симплексного метода. Построение моделей по решению транспортных задач при применении метода минимальной стоимости.
задача [169,2 K], добавлен 06.01.2012Эффективная оценка по методу наименьших квадратов. Корелляционно-регрессионный анализ в эконометрическом моделировании. Временные ряды в эконометрических исследованиях. Моделирование тенденции временного ряда. Расчет коэффициента автокорреляции.
контрольная работа [163,7 K], добавлен 19.06.2015Изучение особенностей метода статистического моделирования, известного в литературе под названием метода Монте-Карло, который дает возможность конструировать алгоритмы для ряда важных задач. Решение задачи линейного программирования графическим методом.
контрольная работа [1,2 M], добавлен 17.12.2014Динамические, стохастические, дискретные модели имитационного моделирования. Предпосылки, технологические этапы машинного моделирования сложной системы. Разработка имитационной модели автоматизированного участка обработки деталей, ее верификация.
дипломная работа [224,3 K], добавлен 05.09.2009Поле корреляции и гипотеза о виде уравнения регрессии. Оценка величины влияния фактора на исследуемый показатель с помощью коэффициента корреляции и детерминации. Определение основных параметров линейной модели с помощью метода наименьших квадратов.
контрольная работа [701,1 K], добавлен 29.03.2011Анализ метода наименьших квадратов для парной регрессии, как метода оценивания параметров линейной регрессии. Рассмотрение линейного уравнения парной регрессии. Исследование множественной линейной регрессии. Изучение ошибок коэффициентов регрессии.
контрольная работа [108,5 K], добавлен 28.03.2018Решение задачи линейного программирования графическим и симплекс-методом. Решение задачи двойственной к исходной. Определение оптимального плана закрепления потребителей за поставщиками однородного груза при условии минимизации общего пробега автомобилей.
контрольная работа [398,2 K], добавлен 15.08.2012Сущность метода наименьших квадратов. Экономический смысл параметров кривой роста (линейная модель). Оценка погрешности и проверка адекватности модели. Построение точечного и интервального прогноза. Суть графического построения области допустимых решений.
контрольная работа [32,3 K], добавлен 23.04.2013Применение метода наименьших квадратов при оценке параметров уравнения регрессии. Зависимость случайных остатков. Предпосылка о нормальном распределении остатков. Особенности определения наличия гомо- и гетероскедастичности. Расчет основных коэффициентов.
курсовая работа [252,1 K], добавлен 26.04.2012Характеристика и описание метода линейного программирования, основные области его применения и ограничения использования. Решение экономических задач, особенности формирования оптимизационной модели, расчет и анализ результатов оптимизации прибыли.
курсовая работа [99,0 K], добавлен 23.03.2010Применение метода равномерного расположения для оптимизации бизнес-процессов. Программное обеспечение Staffware Process Suit, суть его работы и преимущества. Разработка приложения-прототипа для автоматизации применения метода равномерного расположения.
дипломная работа [214,9 K], добавлен 21.08.2016Классификационные принципы методов прогнозирования: фактографические, комбинированные и экспертные. Разработка приёмов статистического наблюдения и анализа данных. Практическое применение методов прогнозирования на примере метода наименьших квадратов.
курсовая работа [77,5 K], добавлен 21.07.2013Понятие, цели и область применения имитационного моделирования. Исследование основных бизнес-процессов транспортной компании. Построение имитационной модели логистических процессов транспортной компании, её калибровка и верификация в целях оптимизации.
дипломная работа [4,7 M], добавлен 18.02.2017
