2017-10-31
464
| Название закона | f(x) | F(x) |
| Экспоненциальный | 
| 
|
| Вейбулла | 
| 
|
Приложение 2
Обратные функции законов распределения
| Название закона распределения | Обратная функция F-1(x) |
| Экспоненциальный | 
|
| Вейбулла | 
|
ПРИЛОЖЕНИЕ З
Листинг модулей программы
Модуль Form1
Модуль Form1 – содержит основную логику взаимодействия с пользователем, методы чтения и записи в файл, выгрузки графиков.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using ZedGraph;
using System.IO;
namespace Kyrsovoi_erm
{
public partial class Form1: Form
{
bool func_nun = true;
Double alpha_value;
Double betta_value;
// Double discret;
int col_count = 1;
Veibolla veib = new Veibolla();
Exponent exp = new Exponent();
Sum_process s_p;
Double mat_oj = 0;
Double disp = 0;
Double k_assim = 0;
Double k_excess = 0;
int size=0;
public Form1()
{
InitializeComponent();
}
private void DrawGraph()
{
//////////////////////////////////////////////////////////////////
////////////////////Функция...................................
//////////////////////////////////////////////////////////////////
Calculate_func();
//////////////////////////////////////////////////////////////////
////////////////////Процесс...................................
//////////////////////////////////////////////////////////////////
Calculate_process();
//////////////////////////////////////////////////////////////////
////////////////////Гистограмма...................................
//////////////////////////////////////////////////////////////////
Calculate_gist();
//////////////////////////////////////////////////////////////////
////////////////////Плотность...................................
//////////////////////////////////////////////////////////////////
Calculate_Plotnost();
//////////////////////////////////////////////////////////////////
////////////////////Мат.Ожидание.................................
//////////////////////////////////////////////////////////////////
Mat_oj_val.Text = Calculate_mat_oj().ToString();
//////////////////////////////////////////////////////////////////
////////////////////Дисперсия.................................
//////////////////////////////////////////////////////////////////
disp_val.Text = Calculate_disp().ToString();
//////////////////////////////////////////////////////////////////
////////////////////Коэфицент ассиметрии.................................
//////////////////////////////////////////////////////////////////
k_assim_val.Text = Calculate_k_assim().ToString();
//////////////////////////////////////////////////////////////////
////////////////////Коэфициет эксцесса.................................
//////////////////////////////////////////////////////////////////
k_excess_val.Text = Calculate_k_excess().ToString();
//////////////////////////////////////////////////////////////////
////////////////////Процесс сумм.................................
//////////////////////////////////////////////////////////////////
Calculate_sum_process();
//////////////////////////////////////////////////////////////////
////////////////////Гистограмма сумм.................................
//////////////////////////////////////////////////////////////////
Calculate_sum_gist();
//////////////////////////////////////////////////////////////////
////////////////////Плотность сумм.................................
//////////////////////////////////////////////////////////////////
Calculate_sum_dansity();
}
private void button1_Click(object sender, EventArgs e)
{
DrawGraph();
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
if (listBox1.SelectedIndex == 0)
{
func_nun = true; // экспонента
textBox2.Enabled = false;
}
else
{
func_nun = false; // вейбулла
textBox2.Enabled = true;
}
}
private void tabControl1_Selected(object sender, TabControlEventArgs e)
{
// if (tabControl1.SelectedIndex == 0)
// button1.Enabled = true;
}
public void Calculate_func()
{
// Получим панель для рисования
GraphPane pane = zedGraph_func.GraphPane;
// Очистим список кривых на тот случай, если до этого сигналы уже были нарисованы
pane.CurveList.Clear();
// Создадим список точек
PointPairList list = new PointPairList();
if (func_nun == true) //экспонента
{
if (Double.TryParse(textBox1.Text, out alpha_value))
{
size = (int)numericUpDown1.Value;
list = exp.Calculate_Exponenta_func(alpha_value, size); // Заполняем список точек
}
else
{
if (!Double.TryParse(textBox1.Text, out alpha_value))
{
MessageBox.Show("Проверьте правильность ввода параметра альфа", "Некорректный ввод");
textBox1.Clear();
}
/*if (!Double.TryParse(textBox3.Text, out discret))
{
MessageBox.Show("Проверьте правильность ввода параметра дельта", "Некорректный ввод");
textBox3.Clear();
}*/
}
}
else
if (func_nun == false)//вейбулла
{
size = (int)numericUpDown1.Value;
if ((Double.TryParse(textBox2.Text, out betta_value)) && (Double.TryParse(textBox1.Text, out alpha_value)))
{
// Заполняем список точек
list = veib.Calculate_Veibolla_func(alpha_value, betta_value, size);
}
else
{
if (!Double.TryParse(textBox1.Text, out alpha_value))
{
MessageBox.Show("Проверьте правильность ввода параметров альфа", "Некорректный ввод");
textBox1.Clear();
}
if (!Double.TryParse(textBox2.Text, out betta_value))
{
MessageBox.Show("Проверьте правильность ввода параметров бетта", "Некорректный ввод");
textBox2.Clear();
}
/*if (!Double.TryParse(textBox3.Text, out discret))
{
MessageBox.Show("Проверьте правильность ввода параметра дельта", "Некорректный ввод");
textBox3.Clear();
}*/
}
}
// Создадим кривую с названием "Sinc",
// которая будет рисоваться голубым цветом (Color.Blue),
// Опорные точки выделяться не будут (SymbolType.None)
string func_name = "Exponenta";
if (!func_nun)
func_name = "Veibulla";
LineItem myCurve = pane.AddCurve(func_name, list, Color.Coral, SymbolType.None);
// Вызываем метод AxisChange (), чтобы обновить данные об осях.
// В противном случае на рисунке будет показана только часть графика,
// которая умещается в интервалы по осям, установленные по умолчанию
zedGraph_func.AxisChange();
// Обновляем график
zedGraph_func.Invalidate();
}
private void Calculate_Plotnost()
{
// if (((func_nun) && (!exp.flistIsEmpty())) || ((!func_nun) && (!veib.flistIsEmpty()))) //нажимали ли кнопку
// {
//if (Int32.TryParse(textBox4.Text, out col_count))// получаем количество коридоров
// {
col_count = (int)numericUpDown2.Value;
PointPairList list = new PointPairList();
PointPairList tlist = new PointPairList();
/* if (((func_nun) && (exp.glistIsEmpty())) || ((!func_nun) && (veib.glistIsEmpty())))
{
if (func_nun)
{
list = exp.Calculate_gist(col_count);
}
else
{
list = veib.Calculate_gist(col_count);
}
}
else
{*/
if (func_nun)
{
list = exp.getGlist();
tlist = exp.Calculate_theoretical_density();
}
else
{
list = veib.getGlist();
tlist = veib.Calculate_theoretical_density();
}
//}
// Получим панель для рисования
GraphPane pane = zedGraphDensity.GraphPane;
// Очистим список кривых на тот случай, если до этого сигналы уже были нарисованы
pane.CurveList.Clear();
string func_name = "Exponenta";
if (!func_nun)
func_name = "Veibulla";
LineItem myCurve = pane.AddCurve("Эксперементальная плотность " + func_name, list, Color.Coral, SymbolType.None);
LineItem myCurve2 = pane.AddCurve("Теоретическая плотность " + func_name, tlist, Color.Blue, SymbolType.None);
// Вызываем метод AxisChange (), чтобы обновить данные об осях.
// В противном случае на рисунке будет показана только часть графика,
// которая умещается в интервалы по осям, установленные по умолчанию
zedGraphDensity.AxisChange();
// Обновляем график
zedGraphDensity.Invalidate();
/* }
else
{
MessageBox.Show("Проверьте правильность ввода параметра 'Количество столбцов'", "Некорректный ввод");
textBox4.Clear();
}*/
/* }
else
{
MessageBox.Show("Нажмите кнопку для генерации значений функции распределения", "Некорректный ввод");
}*/
}
public void Calculate_gist()
{
//if (Int32.TryParse(textBox4.Text, out col_count))// получаем количество коридоров
// {
//button1.Enabled = false;
col_count = (int)numericUpDown2.Value;
// Получим панель для рисования
GraphPane gist_pane = zedGraph_gist.GraphPane;
// Очистим список кривых на тот случай, если до этого сигналы уже были нарисованы
gist_pane.CurveList.Clear();
string func_name;
PointPairList glist;
if (func_nun)
{
func_name = "Exponenta";
glist = exp.Calculate_gist(col_count);
}
else
{
func_name = "Veibulla";
glist = veib.Calculate_gist(col_count);
}
// MessageBox.Show("Задница", "Некорректный ввод");
BarItem bar = gist_pane.AddBar("Гистограмма" + func_name, glist, Color.Blue);
//!!! Расстояния между кластерами (группами столбиков) гистограммы = 0.0
// У нас в кластере только один столбик.
gist_pane.BarSettings.MinClusterGap = 0.0f;
// Вызываем метод AxisChange (), чтобы обновить данные об осях.
zedGraph_gist.AxisChange();
// Обновляем график
zedGraph_gist.Invalidate();
/*}
else
{
if (!Int32.TryParse(textBox4.Text, out col_count))
{
MessageBox.Show("Проверьте правильность ввода параметра 'Количество столбцов'", "Некорректный ввод");
textBox4.Clear();
}
}*/
}
public void Calculate_process()
{
Double [] process = new Double[size];
Double[] index = new Double[size];
if (func_nun)
{
process = exp.getProcess();
}
else
{
process = veib.getProcess();
}
for (int i = 0; i < size; i++)
{
index[i] = i;
}
// Получим панель для рисования
GraphPane pane = zedGraph_process.GraphPane;
// Очистим список кривых на тот случай, если до этого сигналы уже были нарисованы
pane.CurveList.Clear();
string func_name = "Exponenta";
if (!func_nun)
func_name = "Veibulla";
LineItem myCurve = pane.AddCurve("Процесс " + func_name,index, process, Color.Blue, SymbolType.None);
// Вызываем метод AxisChange (), чтобы обновить данные об осях.
// В противном случае на рисунке будет показана только часть графика,
// которая умещается в интервалы по осям, установленные по умолчанию
zedGraph_process.AxisChange();
// Обновляем график
zedGraph_process.Invalidate();
/* }
else
{
MessageBox.Show("Проверьте правильность ввода параметра 'Количество столбцов'", "Некорректный ввод");
textBox4.Clear();
}*/
}
private void сохранитьToolStripMenuItem_Click(object sender, EventArgs e)
{
if (((func_nun) && (!exp.flistIsEmpty())) || ((!func_nun) && (!veib.flistIsEmpty()))) //нажимали ли кнопку
{
saveFileDialog1.Filter = "Текстовый *.txt|*.txt";
saveFileDialog1.ShowDialog();
}
else
{
MessageBox.Show("Нажмите кнопку для генерации значений функции распределения", "Невозможно сохранить");
}
}
public Double Calculate_mat_oj()
{
mat_oj = 0;
Double [] process= new Double[size];
// PointPairList list = new PointPairList();
if (func_nun) //экспонента
{
process = exp.getProcess();
}
else // вейбулла
{
process = veib.getProcess();
}
mat_oj = process.Sum()/size;
return mat_oj;
}
public Double Calculate_disp()
{
disp = 0;
Double [] process = new Double[size];
if (func_nun) //экспонента
{
process = exp.getProcess();
}
else // вейбулла
{
process = veib.getProcess();
}
for (int i = 0; i < size; i++)
{
disp += Math.Pow(process[i] - mat_oj,2);
}
disp = disp / (size - 1);
return disp;
}
public Double Calculate_k_assim()
{
Double[] process = new Double[size];
Double m3 = 0;
if (func_nun) //экспонента
{
process = exp.getProcess();
}
else // вейбулла
{
process = veib.getProcess();
}
for (int i = 0; i < size; i++)
{
m3 += Math.Pow(process[i] - mat_oj, 3);
}
m3 = m3 / (size-1);
k_assim = m3 / Math.Pow(disp,3/2);
return k_assim;
}
public Double Calculate_k_excess()
{
Double[] process = new Double[size];
Double m4 = 0;
if (func_nun) //экспонента
{
process = exp.getProcess();
}
else // вейбулла
{
process = veib.getProcess();
}
for (int i = 0; i < size; i++)
{
m4 += Math.Pow(process[i] - mat_oj, 4);
}
m4 = m4 / (size-1);
k_excess = (m4 / Math.Pow(disp, 2))-3;
return k_excess;
}
public void Calculate_sum_process()
{
Double tay = (Double) numericUpDown3.Value;
PointPairList list = new PointPairList();
if (func_nun) //экспонента
{
s_p = new Sum_process(exp.getProcess(),tay);
}
else // вейбулла
{
s_p = new Sum_process(veib.getProcess(), tay);
}
list = s_p.Calculate_summ_count();
// Получим панель для рисования
GraphPane pane = zedGraph_sum_process.GraphPane;
// Очистим список кривых на тот случай, если до этого сигналы уже были нарисованы
pane.CurveList.Clear();
string func_name = "Exponenta";
if (!func_nun)
func_name = "Veibulla";
LineItem myCurve = pane.AddCurve("Процесс сумм" + func_name,list,Color.Blue, SymbolType.None);
// Вызываем метод AxisChange (), чтобы обновить данные об осях.
// В противном случае на рисунке будет показана только часть графика,
// которая умещается в интервалы по осям, установленные по умолчанию
zedGraph_sum_process.AxisChange();
// Обновляем график
zedGraph_sum_process.Invalidate();
}
public void Calculate_sum_gist()
{
PointPairList list = new PointPairList();
int col_count = (int)numericUpDown2.Value;
list = s_p.Calculate_gist(col_count);
// Получим панель для рисования
GraphPane gist_pane = zedGraph_sum_gist.GraphPane;
// Очистим список кривых на тот случай, если до этого сигналы уже были нарисованы
gist_pane.CurveList.Clear();
string func_name = "Exponenta";
if (!func_nun)
func_name = "Veibulla";
BarItem bar = gist_pane.AddBar("Гистограмма сумм" + func_name, list, Color.Blue);
//!!! Расстояния между кластерами (группами столбиков) гистограммы = 0.0
// У нас в кластере только один столбик.
gist_pane.BarSettings.MinClusterGap = 0.0f;
// Вызываем метод AxisChange (), чтобы обновить данные об осях.
zedGraph_sum_gist.AxisChange();
// Обновляем график
zedGraph_sum_gist.Invalidate();
}
public void Calculate_sum_dansity()
{
// Получим панель для рисования
GraphPane pane = zedGraph_sum_density.GraphPane;
// Очистим список кривых на тот случай, если до этого сигналы уже были нарисованы
pane.CurveList.Clear();
PointPairList list = new PointPairList();
list = s_p.getGlist();
string func_name = "Exponenta";
if (!func_nun)
func_name = "Veibulla";
LineItem myCurve = pane.AddCurve("Процесс сумм" + func_name, list, Color.Coral, SymbolType.None);
// Вызываем метод AxisChange (), чтобы обновить данные об осях.
// В противном случае на рисунке будет показана только часть графика,
// которая умещается в интервалы по осям, установленные по умолчанию
zedGraph_sum_density.AxisChange();
// Обновляем график
zedGraph_sum_density.Invalidate();
}
private void открытьToolStripMenuItem_Click(object sender, EventArgs e)
{
openFileDialog1.Filter = "Текстовый (*.txt)|*.txt";
openFileDialog1.ShowDialog();
}
private void openFileDialog1_FileOk(object sender, CancelEventArgs e)
{
string way;
if (openFileDialog1.FileName!= "")
{
//MessageBox.Show("Все ок");
way = openFileDialog1.FileName;
// Double[] s;
//int count;
//count = 0;
Double[] process;
// PointPairList list = new PointPairList();
Double discret;
// String [] str;
bool err = false;
string line ="";
System.IO.StreamReader file =
new System.IO.StreamReader(way);
if ((line = file.ReadLine())!= null)
{
if (!Int32.TryParse(line, out size))
{
err = true;
}
}
if(((line = file.ReadLine())!= null)&&(!err))
{
if (!Double.TryParse(line, out discret))
{
err = true;
}
}
// Read the file and display it line by line.
int i = 0;
process = new Double[size];
while (((line = file.ReadLine())!= null)&&(i<size)&&(!err))
{
if (!Double.TryParse(line, out process[i]))
{
err = true;
}
i++;
}
if (err)
{
MessageBox.Show("Некорректный формат файла");
file.Close();
}
else
{
file.Close();
exp.Analise_process(process);
veib.Analise_process(process);
exp.Calculate_gist((int)numericUpDown2.Value);
veib.Calculate_gist((int)numericUpDown2.Value);
PointPairList list = new PointPairList();
PointPairList tlist = new PointPairList();
double exp_delta = 0;
double veib_delta = 0;
int alpha_mega = 500;
int betta_mega = 500;
Double[,] exp_mega = new Double[alpha_mega-1,2 ];
Double[,] veib_mega = new Double[(alpha_mega-2)*(betta_mega-1),3];
Double [] min_exp = new Double[2];
Double[] min_veib = new Double[3];
list = exp.getGlist(); // экспонента
int h;
for (h = 1; h < alpha_mega; h++)
{
exp_delta = 0;
exp.Set_alpha(h);
tlist = exp.Calculate_theoretical_density();
for (int j=0; j < list.Count; j++)
{
exp_delta += Math.Abs(list.ElementAt(j).Y - tlist.ElementAt(j).Y);
}
exp_delta = exp_delta / list.Count;
exp_mega[h-1, 0] = h;
exp_mega[h-1, 1] = exp_delta;
if (h == 1)
{
min_exp[0] = exp_mega[0, 0];
min_exp[1] = exp_mega[0,1];
}
if (exp_mega[h - 1, 1] < min_exp[1])
{
min_exp[0] = exp_mega[h-1, 0];
min_exp[1] = exp_mega[h-1, 1];
}
}
list = veib.getGlist(); //вейбулла
int a;
long index =0;
for (a= 2; a < alpha_mega; a++) //экспонета это вейбулла при а = 1
{
for (int b = 1; b < betta_mega; b++)
{
veib_delta = 0;
veib.Set_alpha_betta(a,b);
tlist = veib.Calculate_theoretical_density();
for (int j = 0; j < list.Count; j++)
{
veib_delta += Math.Abs(list.ElementAt(j).Y - tlist.ElementAt(j).Y);
}
veib_delta = veib_delta / list.Count;
veib_mega[index, 0] = a;
veib_mega[index, 1] = b;
veib_mega[index, 2] = veib_delta;
if ((a == 2)&&(b==1))
{
min_veib[0] = veib_mega[0, 0];
min_veib[1] = veib_mega[0, 1];
min_veib[2] = veib_mega[0, 2];
}
if (veib_mega[index, 2] < min_veib[2])
{
min_veib[0] = veib_mega[index, 0];
min_veib[1] = veib_mega[index, 1];
min_veib[2] = veib_mega[index, 2];
}
index++;
}
}
string func_name = "Exponenta";
if (min_exp[1] < min_veib[2])
{
exp.Set_alpha(min_exp[0]);
// al
MessageBox.Show("Экспонента a="+min_exp[0]);
func_nun = true;
list = exp.Calculate_Exponenta_func_from_file();
}
else
{
veib.Set_alpha_betta(min_veib[0],min_veib[1]);
MessageBox.Show("Вейбулла a="+min_veib[0]+" b="+min_veib[1]);
func_nun = false;
list = veib.Calculate_Veobulla_func_from_file();
func_name = "Veibulla";
}
//////////////////////////////////////////////////////////////////
////////////////////Функция...................................
//////////////////////////////////////////////////////////////////
// Получим панель для рисования
GraphPane pane = zedGraph_func.GraphPane;
// Очистим список кривых на тот случай, если до этого сигналы уже были нарисованы
pane.CurveList.Clear();
LineItem myCurve = pane.AddCurve("Функция распределения " + func_name, list, Color.Coral, SymbolType.None);
zedGraph_func.AxisChange();
// Обновляем график
zedGraph_func.Invalidate();
//////////////////////////////////////////////////////////////////
////////////////////Процесс...................................
//////////////////////////////////////////////////////////////////
Calculate_process();
//////////////////////////////////////////////////////////////////
////////////////////Гистограмма...................................
//////////////////////////////////////////////////////////////////
Calculate_gist();
//////////////////////////////////////////////////////////////////
////////////////////Плотность...................................
//////////////////////////////////////////////////////////////////
Calculate_Plotnost();
//////////////////////////////////////////////////////////////////
////////////////////Мат.Ожидание.................................
//////////////////////////////////////////////////////////////////
Mat_oj_val.Text = Calculate_mat_oj().ToString();
//////////////////////////////////////////////////////////////////
////////////////////Дисперсия.................................
//////////////////////////////////////////////////////////////////
disp_val.Text = Calculate_disp().ToString();
//////////////////////////////////////////////////////////////////
////////////////////Коэфицент ассиметрии.................................
//////////////////////////////////////////////////////////////////
k_assim_val.Text = Calculate_k_assim().ToString();
//////////////////////////////////////////////////////////////////
////////////////////Коэфициет эксцесса.................................
//////////////////////////////////////////////////////////////////
k_excess_val.Text = Calculate_k_excess().ToString();
//////////////////////////////////////////////////////////////////
////////////////////Процесс сумм.................................
//////////////////////////////////////////////////////////////////
Calculate_sum_process();
//////////////////////////////////////////////////////////////////
////////////////////Гистограмма сумм.................................
//////////////////////////////////////////////////////////////////
Calculate_sum_gist();
//////////////////////////////////////////////////////////////////
////////////////////Плотность сумм.................................
//////////////////////////////////////////////////////////////////
Calculate_sum_dansity();
}
}
}
private void saveFileDialog1_FileOk(object sender, CancelEventArgs e)
{
string way;
if (saveFileDialog1.FileName!= "")
{
way = saveFileDialog1.FileName;
String[] s;
int count;
Double[] process = new Double [size];
//PointPairList list = new PointPairList();
Double discret;
if (func_nun)
{
count = size + 2;
discret = (exp.getxmax() - exp.getxmin()) / size;
s = new string[count];
s[0] = size.ToString();
s[1] = discret.ToString();
process = exp.getProcess();
for (int i = 2; i < count; i++)
{
s[i] = process[i-2].ToString();
}
}
else
{
count = size + 2;
discret = (veib.getxmax() - veib.getxmin()) / size;
s = new string[count];
s[0] = size.ToString();
s[1] = discret.ToString();
process = veib.getProcess();
for (int i = 2; i < count; i++)
{
s[i] = process[i-2].ToString();
}
}
for (int n = 0; n < count; n++)
{
File.WriteAllLines(way, s);
}
}
}
private void выходToolStripMenuItem_Click(object sender, EventArgs e)
{
string message = "Вы действительно хотите выйти?";
string caption = "Выход";
MessageBoxButtons buttons = MessageBoxButtons.YesNo;
DialogResult result;
// Displays the MessageBox.
result = MessageBox.Show(message, caption, buttons);
if (result == System.Windows.Forms.DialogResult.Yes)
{
// Closes the parent form.
this.Close();
}
//zedGraph_func.MasterPane.GetImage().Save("test.bmp");
}
private void button2_Click(object sender, EventArgs e)
{
if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
{
String way;
if (folderBrowserDialog1.SelectedPath!= null)
way = folderBrowserDialog1.SelectedPath;
else
way = folderBrowserDialog1.RootFolder.ToString();
zedGraph_process.MasterPane.GetImage().Save(way+"\\process.bmp");
zedGraph_func.MasterPane.GetImage().Save(way + "\\function.bmp");
zedGraph_gist.MasterPane.GetImage().Save(way + "\\gistogramm.bmp");
zedGraphDensity.MasterPane.GetImage().Save(way + "\\density.bmp");
zedGraph_sum_process.MasterPane.GetImage().Save(way + "\\sum_process.bmp");
zedGraph_sum_gist.MasterPane.GetImage().Save(way + "\\sum_gistogramm.bmp");
zedGraph_sum_density.MasterPane.GetImage().Save(way + "\\sum_density.bmp");
}
//zedGraph_func.MasterPane.GetImage().Save("test.bmp");
}
}
}
МодульExponent
Данный модуль осуществляет расчет основных характеристик экспоненциального распределения.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ZedGraph;
namespace Kyrsovoi_erm
{
class Exponent
{
private PointPairList flist = new PointPairList();
private PointPairList glist;
private Double alpha=1;
// private Double discret= 0.001;
//private Double ymin = 0;
// private Double ymax = 1;
private Double xmin;
private Double xmax;
private Double[] process;
// private Double[] process_sort;
Double korigor;
Double[] gistX;
int c_count;
public void Set_alpha(Double a)
{
alpha = a;
}
public Double getxmin()
{
return xmin;
}
public Double getxmax()
{
return xmax;
}
public void Analise_process(Double [] p)
{
process = new Double[p.Length];
xmax = process[0];
xmin = process[0];
process = p;
size = p.Length;
// c_count = c;
for (int i = 0; i < process.Length; i++)
{
if (process[i] < xmin)
{
xmin = process[i];
}
if (process[i] > xmax)
{
xmax = process[i];
}
}
}
private int size = 0;
public int getflistCount()
{
return flist.Count();
}
public bool glistIsEmpty()
{
if (glist == null)
return true;
return false;
}
public Double[] getProcess()
{
return process;
}
/* public Double getDiscret()
{
return discret;
}*/
public bool flistIsEmpty()
{
if (flist.Count == 0)
return true;
return false;
}
public PointPairList getGlist()
{
return glist;
}
public PointPairList getFlist()
{
return flist;
}
public void update(Double a, int s)
{
alpha = a;
//discret = d;
size = s;
}
public PointPairList Calculate_Exponenta_func(Double a, int s)
{
process = new Double[s];
//process_sort = new Double[s];
Random r = new Random();
double y;
double x_res;
update(a, s);
flist.Clear();
y = r.NextDouble();
x_res = f_exp_r(a, y);
process[0] = x_res;
xmax = x_res;
xmin = x_res;
flist.Add(x_res, y);
for (int i =1; i < size; i ++)
{
y = r.NextDouble();
x_res=f_exp_r(a,y);
// добавим в список точку
flist.Add(x_res,y);
process[i] = x_res;
if (x_res > xmax)
{
xmax = x_res;
// ymax2 = y;
}
if (x_res < xmin)
{
xmin = x_res;
// ymax2 = y;
}
}
flist.Sort();
/* for (int i = 0; i < size; i++)
{
process_sort[i] = flist.ElementAt(i).X;
}*/
return flist;
}
public PointPairList Calculate_Exponenta_func_from_file()
{
//process_sort = new Double[size];
double x;
double y_res;
flist.Clear();
for (int i = 0; i < size; i++)
{
x = process[i];
y_res = f_exp(x);
flist.Add(x, y_res);
}
flist.Sort();
/* for (int i = 0; i < size; i++)
{
process_sort[i] = flist.ElementAt(i).X;
}*/
return flist;
}
private double f_exp(Double x)
{
if (x == 0)
{
return 0;
}
return 1-(Math.Exp(-alpha*x));
}
private double f_exp_r(Double a, Double y)
{
if (y == 0)
{
return 0;
}
return (-1 / a) * (Math.Log((1 - y), Math.E));
}
private double f_exp_densitY(double x)
{
if (x < 0)
{
return 0;
}
else
{
return alpha*Math.Pow(Math.E,(-alpha*x));
}
}
public PointPairList Calculate_theoretical_density()
{
PointPairList list = new PointPairList();
Double y;
Double x;
Double sum = 0;
for(int i=0;i<c_count;i++)
{
x =gistX[i];
y = f_exp_densitY(x);
sum += y;
//list.Add(x,y);
}
for (int i = 0; i < c_count; i++)
{
x = gistX[i];
y = f_exp_densitY(x);
list.Add(x,y/sum);
}
return list;
}
public PointPairList Calculate_gist(int c_c)
{
c_count = c_c;
Double [] gistY = new Double[c_c];
gistX = new Double[c_c];
korigor = (xmax - xmin) / c_c; //ширина коридора
//Считаем середину для каждого столбика гистограммы
int h = 0;
for (Double i = xmin+korigor/2; i < xmax; i +=korigor)
{
gistX[h] = i;
h++;
}
int j;
for (int i = 0; i < size; i++)
{
j = (int) (((process[i])-xmin) / korigor);
if ((((process[i]) - xmin) % korigor!= 0) && ((process[i])!= xmax))
{
gistY[j] = gistY[j] + 1;
}
else
{
if (((process[i])!= xmax) && ((process[i])!= xmin))
{
gistY[j - 1] = gistY[j - 1] + 1/2;
gistY[j] = gistY[j] + 1/2;
}
else
{
if ((process[i]) == xmax)
gistY[j - 1] = gistY[j - 1] + 1;
if ((process[i]) == xmin)
gistY[j] = gistY[j] + 1;
}
}
}
Double temp=0;
for (int i = 0; i < c_c; i++)
{
gistY[i] = gistY[i] / size;
temp += gistY[i];
}
temp = temp * korigor;
glist = new PointPairList(gistX, gistY);
return glist;
}
}
}
Модуль Veibulla
Данный модуль осуществляет расчет основных характеристик распределения Вейбулла
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ZedGraph;
namespace Kyrsovoi_erm
{
public class Veibolla
{
private PointPairList flist = new PointPairList();
private Double alpha=1;
private Double betta=1;
// private Double discret;
// private Double ymin = 0;
// private Double ymax = 1;
private PointPairList glist;
private int size = 0;
private int c_count; // количество коридоров
private Double korigor;
private Double xmin;
private Double xmax;
private Double [] process;
Double[] gistX; // серидины коридоров
public Double[] getProcess()
{
return process;
}
public void Set_alpha_betta(Double a,Double b)
{
alpha = a;
betta = b;
}
public void Analise_process(Double[] p)
{
process = new Double[p.Length];
xmax = process[0];
xmin = process[0];
process = p;
size = p.Length;
// c_count = c;
for (int i = 0; i < process.Length; i++)
{
if (process[i] < xmin)
{
xmin = process[i];
}
if (process[i] > xmax)
{
xmax = process[i];
}
}
}
public PointPairList Calculate_Veobulla_func_from_file()
{
//process_sort = new Double[size];
double x;
double y_res;
flist.Clear();
for (int i = 0; i < size; i++)
{
x = process[i];
y_res = f_veib(x);
flist.Add(x, y_res);
}
flist.Sort();
return flist;
}
public bool glistIsEmpty()
{
if (glist == null)
return true;
return false;
}
public bool flistIsEmpty()
{
if (flist.Count == 0)
return true;
return false;
}
public int getflistCount()
{
return flist.Count();
}
public PointPairList getGlist()
{
return glist;
}
/* public Double getDiscret()
{
return discret;
}
* */
public PointPairList getFlist()
{
return flist;
}
public void update(Double a, Double b, int s)
{
alpha = a;
betta = b;
size = s;
// discret = d;
}
public PointPairList Calculate_Veibolla_func(Double a, Double b, int s)
{
process = new Double [s];
Random r = new Random();
double y;
double x_res;
update(a,b,s);
flist.Clear();
y = r.NextDouble();
x_res = f_veib_r(a,b,y);
process[0] = x_res;
xmax = x_res;
xmin = x_res;
flist.Add(x_res, y);
// Сохраняем значения в объекте класса
/* for (double y = ymin; y < ymax; y += d)
{
x_res = f_veib(a,b,y);
// добавим в список точку
flist.Add(x_res,y);
if (x_res > xmax)
xmax = x_res;
}*/
for (int i = 1; i < size; i++)
{
y = r.NextDouble();
x_res = f_veib_r(a,b,y);
// добавим в список точку
flist.Add(x_res, y);
process[i] = x_res;
if (x_res > xmax)
{
xmax = x_res;
// ymax2 = y;
}
if (x_res < xmin)
{
xmin = x_res;
// ymax2 = y;
}
}
flist.Sort();
return flist;
}
private double f_veib(Double x)
{
if (x == 0)
{
return 0;
}
return 1-Math.Exp(-betta*Math.Pow(x,alpha));
}
private double f_veib_r(Double a, Double b, Double y)
{
if (y == 0)
{
return 0;
}
return Math.Pow(-1 / b * Math.Log(1 - y, Math.E), 1/a); //(-1 / Double.Parse(textBox1.Text)) * (Math.Log((1 - y), Math.E));
}
private double f_veib_densitY(double x)
{
if (x < 0)
{
return 0;
}
else
{
return alpha *betta* Math.Pow(x, (alpha - 1))*Math.Pow(Math.E,(-betta*Math.Pow(x,alpha)));
}
}
public PointPairList Calculate_theoretical_density()
{
PointPairList list = new PointPairList();
Double y;
Double x;
Double sum = 0;
for (int i = 0; i < c_count; i++)
{
x = gistX[i];
y = f_veib_densitY(x);
sum += y;
//list.Add(x,y);
}
for (int i = 0; i < c_count; i++)
{
x = gistX[i];
y = f_veib_densitY(x);
list.Add(x, y / sum);
}
return list;
}
public Double getxmin()
{
return xmin;
}
public Double getxmax()
{
return xmax;
}
public PointPairList Calculate_gist(int c_c)
{
c_count = c_c;
Double [] gistY = new Double[c_c];
gistX = new Double[c_c];
korigor = (xmax - xmin) / c_c; //ширина коридора
//Считаем середину для каждого столбика гистограммы
int h = 0;
for (Double i = xmin+korigor/2; i < xmax; i +=korigor)
{
gistX[h] = i;
h++;
}
int j;
for (int i = 0; i < size; i++)
{
j = (int)(((process[i]) - xmin) / korigor);
if ((((process[i]) - xmin) % korigor!= 0) && ((process[i])!= xmax))
{
gistY[j] = gistY[j] + 1;
}
else
{
if (((process[i])!= xmax) && ((process[i])!= xmin))
{
gistY[j - 1] = gistY[j - 1] + 1/2;
gistY[j] = gistY[j] + 1/2;
}
else
{
if ((process[i]) == xmax)
gistY[j - 1] = gistY[j - 1] + 1;
if ((process[i]) == xmin)
gistY[j] = gistY[j] + 1;
}
}
}
Double temp=0;
for (int i = 0; i < c_c; i++)
{
gistY[i] = gistY[i] / size;
temp += gistY[i];
}
temp = temp * korigor;
glist = new PointPairList(gistX, gistY);
return glist;
}
}
}
Модуль Sum_process
В данном модуле рассчитываются и храняться основные параметры сумм значений случайных величин.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ZedGraph;
namespace Kyrsovoi_erm
{
public class Sum_process
{
private Double[] sourse_process;
private int size;
private Double tay;
private PointPairList dest_process;
private Double c_count;
private Double[] gistX;
private Double xmin;
private Double xmax;
private PointPairList glist;
public PointPairList getGlist()
{
return glist;
}
public Sum_process(Double[]s_process,Double t)
{
tay = t;
size = s_process.Length;
sourse_process = new Double[size];
sourse_process = s_process;
}
public PointPairList Calculate_summ_count()
{
dest_process = new PointPairList();
Double sum;
int j;
int i_i;
for (int i = 0; i < size; i++)
{
i_i = i;
sum= sourse_process[i];
j = 0;
while ((sum<tay)&&(i_i+1<size))
{
j++;
sum += sourse_process[i_i++];
}
if (i == 0)
{
xmin = j;
xmax = j;
}
if (j < xmin)
{
xmin = j;
}
if (j > xmax)
{
xmax = j;
}
dest_process.Add(i,j);
}
return dest_process;
}
public PointPairList Calculate_gist(int c_c)
{
c_count = c_c;
Double[] gistY = new Double[c_c];
gistX = new Double[c_c];
Double korigor = (xmax - xmin) / c_c; //ширина коридора
//Считаем середину для каждого столбика гистограммы
int h = 0;
for (Double i = xmin + korigor / 2; i < xmax; i += korigor)
{
gistX[h] = i;
h++;
}
int j;
for (int i = 0; i < size; i++)
{
Double temp2 = dest_process.ElementAt(i).Y;
j = (int)(((dest_process.ElementAt(i).Y) - xmin) / korigor);
//j = (int)temp1;
if ((((dest_process.ElementAt(i).Y) - xmin) % korigor!= 0) && ((dest_process.ElementAt(i).Y)!= xmax))
{
gistY[j] = gistY[j] + 1;
}
else
{
if (((dest_process.ElementAt(i).Y)!= xmax) && ((dest_process.ElementAt(i).Y)!= xmin))
{
gistY[j - 1] = gistY[j - 1] + 1 / 2;
gistY[j] = gistY[j] + 1 / 2;
}
else
{
if ((dest_process.ElementAt(i).Y) == xmax)
gistY[j - 1] = gistY[j - 1] + 1;
if ((dest_process.ElementAt(i).Y) == xmin)
gistY[j] = gistY[j] + 1;
}
}
}
// Double temp = 0;
for (int i = 0; i < c_c; i++)
{
gistY[i] = gistY[i] / size;
// temp += gistY[i];
}
//temp = temp * korigor;
glist = new PointPairList(gistX, gistY);
return glist;
}
}
}
