1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
|
public class fFisher
{
private Func.OutPerem Perem;
//массив с параметром К1
private double[] arrU_1;
private double[] arrU2_1;
private double[] arrXi2_1;
//массив с параметром К2
private double[] arrU_2;
private double[] arrU2_2;
private double[] arrXi2_2;
//
//Не передаваемые переменные
//СВ распределенная по закону Фишера
private double[] arrFisher2;
private double[] arrF_Sorted;
private double sumFisher2;
private double[] arB;
private double[] arA;
private double[] arG_a;
private double[] arG;
public double[] _arrFisher2
{
get { return arrFisher2; }
set { arrFisher2 = value; }
}
public double _sumFisher2
{
get { return sumFisher2; }
set { sumFisher2 = value; }
}
public double[] _arG
{
get { return arG; }
set { arG = value; }
}
public void FuncFisher(Func.OutPerem Perem)
{
this.Perem=Perem;
//
//Этот метод рассчитывает СВ распределенную по закону Фишера
//Нормальным законом распределения, является системная СВ
//
double sumR_1 = 0;
double sumU2_1 = 0;
double sumR_2 = 0;
double sumU2_2 = 0;
Perem._sumFisher = 0;
sumFisher2 = 0;
arrU_1 = new double[(int)Perem._K1];
arrU2_1 = new double[(int)Perem._K1];
arrU_2 = new double[(int)Perem._K2];
arrU2_2 = new double[(int)Perem._K2];
arrXi2_1 = new double[(int)Perem._nR];
arrXi2_2 = new double[(int)Perem._nR];
Perem._arrFisher = new double[(int)Perem._nR];
arrFisher2 = new double[(int)Perem._nR];
arrF_Sorted = new double[(int)Perem._nR];
Random rnd1 = new Random();
//
//Массив фишера
//
for (int i = 0; i < Perem._nR; i++)
{
//
//Массив X2 с параметром K1
//
sumU2_1 = 0;
for (int i_k1 = 0; i_k1 < Perem._K1; i_k1++)
{
sumR_1 = 0;
for (int ir = 0; ir < 12; ir++)
{
sumR_1 += rnd1.NextDouble() * 1.0;
}
arrU_1[i_k1] = sumR_1 - 6;
arrU2_1[i_k1] = Math.Pow(arrU_1[i_k1], 2);
sumU2_1 += arrU2_1[i_k1];
}
//заполнение массива 1-ой переменной хи2
arrXi2_1[i] = sumU2_1;
//
//Массив Х2 с параметром К2
//
sumU2_2 = 0;
for (int i_k2 = 0; i_k2 < Perem._K2; i_k2++)
{
sumR_2 = 0;
for (int ir = 0; ir < 12; ir++)
{
sumR_2 += rnd1.NextDouble() * 1.0;
}
arrU_2[i_k2] = sumR_2 - 6;
arrU2_2[i_k2] = Math.Pow(arrU_2[i_k2], 2);
sumU2_2 += arrU2_2[i_k2];
}
//заполнение массива 2-ой переменной хи2
arrXi2_2[i] = sumU2_2;
//заполнение массива фишера
Perem._arrFisher[i] = (arrXi2_1[i] / Perem._K1) / (arrXi2_2[i] / Perem._K2);
arrFisher2[i] = Math.Pow(Perem._arrFisher[i], 2);
Perem._sumFisher += Perem._arrFisher[i];
sumFisher2 += arrFisher2[i];
arrF_Sorted[i] = Perem._arrFisher[i];
}
//Расчет теоретических велечин
Perem._MatOT_F = Perem._K2 / (Perem._K2 - 2); //Мат ожидание по Фишеру
Perem._DispT_F = 2 * (Math.Pow(Perem._K2, 2) * (Perem._K1 + Perem._K2 - 2)) / (Perem._K1 *
Math.Pow((Perem._K2 - 2), 2) * (Perem._K2 - 4)); //Дисперсия по фишеру
Perem._SkoT_F = Math.Sqrt(Perem._DispT_F);
//Расчет практических величин
Perem._MatO_F = Perem._sumFisher / Perem._nR;
Perem._Disp_F = (sumFisher2 / Perem._nR) - Math.Pow(Perem._MatO_F, 2);
Perem._Sko_F = Math.Sqrt(Perem._Disp_F);
//Сортировка
Array.Sort(arrF_Sorted);
Perem._MaxFisher = (float)arrF_Sorted[(int)Perem._nR - 1];
}
public void FuncTable(Func.OutPerem Perem)
{
this.Perem = Perem;
//
//Этот метод рассчитывает все переменные необходимые для заполнения таблицы
//и проверочных контрольных сумм (МО, СКО, Дисп: практические и теоретические)
//
//переменные
//не вводимные
double SumInt = 0;
Perem._sumXi = 0;
double f_f1, f_f2, f_f3, f_f6;
//
//переменная для таблицы расчетов хи2
//
arB = new double[Perem._Ntb];
Perem._arTable = new double[Perem._Ntb, 7];
arA = new double[Perem._Ntb];
double[] f_f4 = new double[Perem._Ntb];
double[] f_f5 = new double[Perem._Ntb];
double[] arSorted = new double[Perem._Ntb];
//
//другие переменные
//
FuncFisher(Perem);
Perem._Int = Perem._MaxFisher / Perem._Ntb; //шаг интервала по Маск(Фишер)
//
//
Funcf_F();
//
//
f_f1 = arG[0];
f_f2 = arG[1] * arG[2];
f_f3 = Math.Pow((Perem._K1 / Perem._K2), (Perem._K1 / 2));
f_f6 = 1 * (Perem._K1 + Perem._K2) / 2;
//
//Массив для N таблицы
//
for (int a = 0; a < Perem._Ntb; a++)
{
Perem._arTable[a, 0] = a + 1; //arN
SumInt += Perem._Int;
Perem._arTable[a, 1] = SumInt; //arInt
//Расчет теоретического количества попаданий
arA[a] = Perem._arTable[a, 1] - Perem._Int / 2;
f_f4[a] = Math.Pow(arA[a], ((Perem._K1 - 2) / 2));
f_f5[a] = Math.Pow((1 + ((Perem._K1 * arA[a]) / Perem._K2)), f_f6);
arB[a] = (f_f1 / f_f2) * f_f3 * (f_f4[a] / f_f5[a]);
Perem._arTable[a, 4] = Perem._Int * arB[a]; //arPi
}
//
//перебирание R с условием попадания в определный интервал
//
for (int an = 0; an < Perem._nR; an++) //перебирание R
{
for (int a = 0; a < Perem._Ntb; a++) //массив попаданий
{
if ((Perem._arTable[a, 1] - Perem._Int) <= Perem._arrFisher[an] && Perem._arrFisher[an] <= Perem._arTable[a, 1])
//условие, что
//если R попдает в интервал (значение при первом интервале arInt[0]=0.1)
// от 0 до Int (Int = 0.1 всегда), то попадание зачисляется в счетчик arNi[0]
{
Perem._arTable[a, 2]++; //счетчик попаданий
Perem._arTable[a, 6] = Perem._arTable[a, 4] * Perem._nR;//расчет вероятности попаданий теоритической
Perem._arTable[a, 3] = Math.Pow((Perem._arTable[a, 2] - Perem._arTable[a, 6]), 2) /
Perem._arTable[a, 6];//расчет хи2
Perem._arTable[a, 5] = Perem._arTable[a, 2] / Perem._nR;//расчет частоты arTable_П
}
}
}
for (int a = 0; a < Perem._Ntb; a++)
{
Perem._sumXi += Math.Round(Perem._arTable[a, 3], 4); //посчет суммы по массивы хи2
}
}
public void Funcf_F()
{
//
//Этот метод предназначен для рассчета величины Гамма с параметрами
//К1 и К2
//
arG_a = new double[3];
arG = new double[3];
arG_a[0] = (Perem._K1 + Perem._K2) / 2; //G1_a
arG_a[1] = Perem._K1 / 2; //G2_a
arG_a[2] = Perem._K2 / 2; //G3_a
//Унивирсальный метод рассчета Гаммы
for (int i = 0; i < 3; i++)
{
arG[i] = 1;
int G_shag = 1; // Изначальный шаг фактариала
int G_fakt = 1; //Величина фактариала
if ((arG_a[i] - Math.Floor(arG_a[i])) == 0)
//услови, что если крато двум
{
for (int G_i = 1; G_i < (int)Math.Floor(arG_a[i]); G_i++)
{
arG[i] *= G_i;
}
}
else
{
//если нет, то:
for (int G_i = 0; G_i < (int)Math.Floor(arG_a[i] - 1); G_i++)
{
G_shag += 2;
G_fakt *= G_shag;
}
arG[i] = (Math.Sqrt(Math.PI) * G_fakt) / Math.Pow(2, Math.Floor(arG_a[i]));
}
}
}
public void Max(Func.OutPerem Perem)
{
this.Perem = Perem;
//поиск максимального числа попаданий
Perem._maxNi = Perem._arTable[0, 2];
for (int iMaxNi = 0; iMaxNi < Perem._Ntb; iMaxNi++)
{
if (Perem._arTable[iMaxNi, 2] > Perem._maxNi)
{
Perem._maxNi = Perem._arTable[iMaxNi, 2];
}
else if (Perem._arTable[iMaxNi, 6] > Perem._maxNi)
{
Perem._maxNi = Perem._arTable[iMaxNi, 6];
}
else
{
Perem._maxNi = Perem._maxNi;
}
}
for (int iMaxVer = 0; iMaxVer < Perem._Ntb; iMaxVer++)
{
if (Perem._arTable[iMaxVer, 4] > Perem._maxVer)
{
Perem._maxVer = Perem._arTable[iMaxVer, 4];
}
else if(Perem._arTable[iMaxVer,5]>Perem._maxVer)
{
Perem._maxVer = Perem._arTable[iMaxVer, 5];
}
else
{
Perem._maxVer = Perem._maxVer;
}
}
}
}
|
