Искусственный интелект

{            

func = new DiscreteDistributionFunction(values);//создаем экземпляр функции             

return func;//возвращаем созданный объект        

}         

//конструктор        

private DiscreteDistributionFunction(List<Point> values)        

{            

func = this;//сохраняем в func адрес создаваемого объекта             

Values = values;//сохраняем пришедшие точки            

double control = 0;// проверяем чтобы суммарная вероятность была равна 1             

for (int i = 0; i < Values.Count; i++)            

{                

control += ((Point)Values[i]).GetP;            

}            

int tochnost = 10000;//настройка точности проверки 10000-до 4 знака, 1000 - до 3 знака включительно и т.д.             

if ((Math.Round(control * tochnost) / tochnost) != 1)            

{                

//Проверка на то, что суммарная вероятность около 1                 

throw new Exception("Суммарная вероятность должна быть равна 1\n");             

}        

}         

//приватный конструктор        

private DiscreteDistributionFunction()        

{            

func = this;//запрещает создание через конструктор напрямую         

}

         

//возвращает значение "ступенчатой" функции в точке         

public double GetFunctionValue(double x)        

{            

//Возвращает значение дискретной функции распредения             

if (x <= Values[0].GetX)            

{                

return 0;//если меньше минимального            

}            

if (x >= Values[Values.Count - 1].GetX)            

{                

return 1;//если больше максимального            

}            

double val = Values[0].GetX;//извлекаем первое значение             

double probability = 0;//вероятность            

double y = 0;            

for (int i = 1; i < Values.Count; i++)// для всех точек СВ            

{                

if (x < val)//если х < текущей точки                

{                    

y = probability;                    

if (y < 0)//округление y                    

{                        

return 0;                    

}                    

else                    

{                        

if (y > 1)                        

{                            

return 1;                        

}                        

else                        

{                            

return y;                        

}                    

}                

}                

val = Values[i].GetX;//переход к следущей точке                

probability += Values[i - 1].GetP;// увеличиваем вероятность             

}            

return probability;        

}         

//возвращает значение обратной функции в точке         

public double GetInverseFunctionValue(double y)        

{            

//Возвращает значение обратной дискретной функции распределения             

if (y < 0 || y > 1)            

{                

throw new Exception("Обратная функция существует только в интервале от 0 до 1");             

}            

double probability = 0;            

for (int i = 0; i < Values.Count; i++)//для всех точек            

{                

probability += Values[i].GetP;//увеличиваем вероятность                 

if (y <= probability)//если y <= текущей вероятности                 

{                    

return Values[i].GetX;// возвращаем х текущей точки                 

}            

}            

return Values[Values.Count - 1].GetX;        

}         

//возвращает i-ю точку дискретной СВ        

public Point GetPoint(int number)        

{            

return Values[number];        

}         

//возвращает количество точек в дискретной СВ         

public int GetNumberOfPoints()        

{            

return Values.Count;        

}         

//возвращает значение дискретной функции плотности в точке         

public double GetDensityFunctionValue(double x)        

{            

if (x < Values[0].GetX)//если меньше минимального             

{                

return 0;            

}            

if (x > Values[Values.Count - 1].GetX)//если больше максимального             

{                

return 0;            

}            

double y = 0;            

for (int i = 1; i < Values.Count; i++)//для всех элементов             

{                

double val = Values[i].GetX;                

if (x <= val)// находим между какими двумя точками находится х                 

{                    

double x1 = Values[i - 1].GetX;                    

double x2 = Values[i].GetX;                    

double y1 = Values[i - 1].GetP;                    

double y2 = Values[i].GetP;                    

y = y1 + ((x - x1) * (y2 - y1)) / (x2 - x1);//линейно интерполируем                     

break;//прерываем цикл                

}            

}            

return y;        

}         

//возвращает мат ожидание СВ        

public double GetExpectation()        

{            

double M = 0;//мат.ожидание            

for (int i = 0; i < this.GetNumberOfPoints(); i++)// для всех точек дискретной функции             

{                

//прибавляем к М произведение х на вероятность в текущей точке                 

M += this.GetPoint(i).GetP * this.GetPoint(i).GetX;            

}            

return M;        

}         

//возвращает СКО СВ        

public double GetMeanSquareDeviation()        

{          

 

 

            return Math.Sqrt(GetDispersion());         

}         

//возвращает дисперсию        

public double GetDispersion()        

{            

double M = this.GetExpectation();//получаем мат.ожидание             

double D = 0;            

for (int i = 0; i < this.GetNumberOfPoints(); i++)//для всех точек             

{                

//прибавляем к дисперсии очередное значение                 

D += this.GetPoint(i).GetP * Math.Pow((this.GetPoint(i).GetX - M), 2);            

}            

return D;        

}         

//возвращает минимальное значение СВ        

public double Xmin()        

{            

return this.GetInverseFunctionValue(0);        

}         

//возвращает масимальное значение СВ        

public double Xmax()        

{            

return this.GetInverseFunctionValue(1);}}    

public class DiscreteInverseGenerator:IGenerator    

{        

private DiscreteDistributionFunction Function = null;        

Random BaseGenerator = new Random();//генератор базовой случайной величины

         

//конструктор        

public DiscreteInverseGenerator(List<Point> Values)        

{            

Function = DiscreteDistributionFunction.Create(Values);//получаем экземпляр функции распределения         

}         

//сгенерировать очередное значение        

public double GenerateValue()        

{            

double x1 = BaseGenerator.NextDouble();// генерация очередного значения базовой случайной величины             

double result = Function.GetInverseFunctionValue(x1);//получение значения обратной функции распределения             

return result;        

}    

}

 

 

//алгоритм для  генерации случайной величины  универсальным методом

 

class UniversalDistributionFunction : IDistributionFunction , IDensityFunction     

{        

private static UniversalDistributionFunction func = null;         

private List<Inflection> Values = null;//массив точек перегиба         

private List<double> square = new List<double>();        

double control = 0;        

//метод создания        

public static UniversalDistributionFunction Create()        

{            

return func;        

}         

public static UniversalDistributionFunction Create(List<Inflection> values)         

{            

func = new UniversalDistributionFunction(values);            

return func;        

}         

//конструктор        

private UniversalDistributionFunction()        

{            

func = this;        

}         

//конструктор        

private UniversalDistributionFunction(List<Inflection> values)         

{            

func = this;            

Values = values;                        

for (int i = 1; i < Values.Count; i++)            

{                

square.Add((Values[i].GetX - Values[i - 1].GetX) * (Values[i].GetY + Values[i - 1].GetY) / 2);                 

control += square[i - 1];            

}            

//int tochnost = 10;//настройка точности проверки 10000-до 4 знака, 1000 - до 3 знака включительно и т.д.             

//if ((Math.Round(control * tochnost) / tochnost) != 1)            

//{            

//    //Проверка на то, что суммарная вероятность около 1             

//    throw new Exception("Суммарная вероятность должна быть равна 1\n");             

//}        

}         

//возвращает значение функции в точке        

public double GetFunctionValue(double x)        

{            

if (x < Values[0].GetX)            

{                

return 0;            

}            

if (x > Values[Values.Count - 1].GetX)            

{                

return 1;            

}            

double y = 0;            

for (int i = 1; i < Values.Count; i++)            

{                

if(x<=Values[i].GetX)                

{                    

y += (x - Values[i - 1].GetX) * (Values[i - 1].GetY + this.GetDensityFunctionValue(x)) / 2;                     

if (y < 0)                    

{                        

return 0;                    

}                    

else                    

{                        

if (y > 1)                        

{                            

return 1;                        

}                        

else                        

{                            

return y;                        

}                    

}                

}                

y += square[i - 1];            

}            

return y;        

}         

//возвращает значение обратной функции в точке         

public double GetInverseFunctionValue(double y)        

{            

//todo: InverseFunctionValue             

if (y < 0 || y > 1)            

{                

throw new Exception("Обратная функция существует только в интервале от 0 до 1");             

}            

if(y==0)            

{                

return Values[0].GetX;            

}            

if(y==1)            

{                

return Values[Values.Count - 1].GetX;            

}            

double Prevx = 0;            

double x = -1;            

double FirstBorder = Values[0].GetX;            

double SecondBorder = Values[Values.Count - 1].GetX;            

do            

{                

Prevx = x;                

x = this.GetFunctionValue(FirstBorder + (SecondBorder - FirstBorder) / 2);                 

if (y > x)                

{                    

FirstBorder += (SecondBorder - FirstBorder)/2;                

}                

else                

{                    

SecondBorder = FirstBorder + (SecondBorder - FirstBorder)/2;                

}            

}            

while (Math.Abs(Prevx - x) > 0.0000000001);

             

return x;}        

//Возвращает значение функции плотности в точке         

public double GetDensityFunctionValue(double x)        

{            

if (x < Values[0].GetX)            

{                

return 0;            

}            

if (x > Values[Values.Count - 1].GetX)            

{                

return 0;            

}            

double y = 0;            

for (int i = 1; i < Values.Count; i++)            

{                

double val = Values[i].GetX;                

if (x <= val)                

{                    

double x1 = Values[i - 1].GetX;                    

double x2 = Values[i].GetX;                    

double y1 = Values[i - 1].GetY;                    

double y2 = Values[i].GetY;                    

y = y1 + ((x - x1) * (y2 - y1)) / (x2 - x1);                    

break;                

}            

}            

return y;        

}         

//возвращает математическое ожидание СВ         

public double GetExpectation()        

{            

double step = (Xmax() - Xmin())/100;            

double prevM = 0;            

double M = 1;            

while (Math.Abs(M - prevM) > 0.000001)            

{                

prevM = M;                

double current = 0;                

for (double x = Xmin(); x < Xmax(); x += step)                

{                    

current += step*((x + step)*GetDensityFunctionValue(x + step) + x*GetDensityFunctionValue(x))/2;                 

}                

M = current;                

step /= 2;            

}            

return M;        

}         

//возвращает СКО        

public double GetMeanSquareDeviation()        

{            

return Math.Sqrt(GetDispersion());        

}         

//возвращает дисперсию