gumen_kurs / progr / =progr3= / func3

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
#include <iostream.h>

#define n 500		// MAX количество точек апроксимации начальной функции плотности
#define n_v 5000	// размер выборки св  
#define m 100		// количество карманов 
#define n_i 10		// количество интервалов 

void main (void) 
{
	float tmp;			// временная переменная
	float tmp2;			// временная переменная

	int n_real=0;		// рельное число точек апроксимации
	int m_real;			// реальное количество карманов
	
	float integral;		// интеграл
	float y_min=0;		// минимальное значение св
	float y_max;		// максисмальное значение св

	float kolm;			// метрика по КОЛМОГОРОВУ
	float pirs;			// метрика по ПИРСОНУ

	int i=0;			// счетчик итераций
	int j=0;			// счетчик итераций

	float mas_y[2][n];  // массив значений функции плотности и её переменной 

	//--- Массив элементарных интегралов ---
	// [0] - нижняя граница
	// [1] - верхняя граница
	// [2] - интреграл от верхней до нижней границы
	float mas_integr[3][n-1]; 
	//--- Конец массива элементарных интегралов ---

	//--- Массив значений функции распределения вероятностей и её переменная ---
	// [0] - нижняя граница
	// [1] - верхняя граница
	// [2] - интреграл от верхней до нижней границы + все предыдущие интегралы
	float mas_fy[3][n];			
	//--- Конец массива значений функции распределения вероятностей и её переменных ---

	//--- Массив значений функции распределения вероятностей для сформированной св и её переменная ---
	// [0] - нижняя граница
	// [1] - верхняя граница
	// [2] Количество попаданий св и интервал от верхней границы до нуля деленное на размер выборки
	float mas_fy_sv[3][n];			
	int   mas_fy_sv_count[n]; // количество по интервалам
	//--- Конец массива значений функции распределения вероятностей ---

	float mas_bsv[n_v];		// массив значений БСВ

	//--- Массив карманов ---
	// [0] нижний предел кармана 
	// [1] верхний предел кармана
	// [2] объем кармана
	// [3] длинна кармана
	float mas_karman[4][m];	
	//--- Конец массива карманов ---

	float karman_vel;	// объем (интеграл, площадь) кармана
	float karman_real;	// объем текущего кармана
	
	//--- Массив карманов соответствия---
	// [0] Номер п/п
	// [1] Верхняя граница по СВ
	// [2] Верхняя граница по БСВ
	float mas_karman_sootv[3][m];
	//--- Конец массива карманов соответствия ---
	
	float mas_sv[n_v];	// массив случайной величины

	//--- Массив числа попаданий св в интервалы ---
	// [0] Нижняя граница интервала
	// [1] Верхняя граница интервала
	// [2] Количество попаданий случайной величины в интервал
	float mas_i[3][n_i];
	float mas_i_Pk[3][n_i]; // то же само, но для первоначальной функции
	//--- Конец массива попаданий св в интервалы ---

	FILE *f1, *f2, *f3, *f4, *f5;

	srand((unsigned)time(NULL));

	//--- Ввод из файла file1.txt ------------------------------------
	//----------------------------------------------------------------
	//-- Первый столбец = значения случайной величины               --
	//-- Второй столбец = вероятность этой сл. величины             --
	//----------------------------------------------------------------
	if((f1=fopen("file1.txt","r"))==NULL) {
		printf("NO!!!\n");
	} else {
		for(i=0; i<n; i++) {
			fscanf(f1,"%f",&mas_y[0][i]);
			fscanf(f1,"%f",&mas_y[1][i]);
		}
		fclose(f1);
	}
	//--- Конец ввода из файла file1.txt -----------------------------

	//--- Генерция БСВ ---
	for (i=0, tmp=0; i<n_v; i++)
	{
		tmp=(float)(rand()%100);
		tmp/=99;
		mas_bsv[i]=tmp;
	}
	//--- Конец генерции БСВ ---

	//--- Вычисление элементарных интегралов ---------
	//-- общего интеграла, и фактическое количество --
	//-- точек апроксимации --------------------------
	for (i=1, integral=0, tmp=0; i<n; i++) {
		mas_integr[0][i-1]=mas_y[0][i-1];
		mas_integr[1][i-1]=mas_y[0][i];
		tmp = ( (mas_y[0][i]-mas_y[0][i-1]) * (mas_y[1][i]+mas_y[1][i-1])/2 );
		integral += tmp;
		if (integral<1.000000000) {
			mas_integr[2][i-1]=tmp;
		} else {
			mas_integr[2][i-1]=float(integral-1.000000000);
			n_real = i;
			y_max  = mas_y[0][i];
			break;
		}
	}
	//--- Конец вычисления элементарных интегралов ---

	//--- Вычисление функции распределения вероятностей ---
	for (i=0, tmp=0; i<n_real; i++) {
		mas_fy[0][i]=mas_integr[0][i];
		mas_fy[1][i]=mas_integr[1][i];
		tmp+=mas_integr[2][i];
		mas_fy[2][i]=tmp;
	}
	//--- Конец вычисления функции распределения вероятностей ---

	//--- Вычисление пределов карманов на основе количества корманов ---
	karman_vel=1;
	karman_vel/=m;
	for (i=0, karman_real=0, j=0; i<n_real; i++) {
		if (karman_real==0) {
			mas_karman[0][j]=mas_integr[0][i];
		}
		karman_real+=mas_integr[2][i];
		if (karman_real>karman_vel) {
			mas_karman[1][j] = mas_integr[1][i];
			mas_karman[2][j] = karman_real;
			mas_karman[3][j] = mas_karman[1][j]-mas_karman[0][j];
			karman_real=0;
			j++;				
		}
	}
	m_real = j;
	//--- Конец вычисления пределов карманов ---

	//--- Вычисление соответствия номерами карманов и БСВ ---
	tmp=y_max/(m_real);
	tmp2=float((1.0)/(m_real));
	mas_karman_sootv[0][0]=float(0);
	mas_karman_sootv[1][0]=tmp;
	mas_karman_sootv[2][0]=tmp2;
	for (i=1; i<m_real; i++) {
		mas_karman_sootv[0][i]=float(i);
		mas_karman_sootv[1][i]=mas_karman_sootv[1][i-1]+tmp;
		mas_karman_sootv[2][i]=mas_karman_sootv[2][i-1]+tmp2;
	}
	//--- Конец вычисления соответствия номерами карманов и БСВ ---

	//--- Вычисление СВ ---
	for (i=0; i<n_v; i++) {
		for (j=0; j<=m_real; j++) {
			if (mas_karman_sootv[2][j]>=mas_bsv[i]) {
				mas_sv[i]=mas_karman[0][j]+(mas_karman[3][j]*mas_bsv[n_v-i-1]);
				break;
			}
		}
	}
	//--- Конец вычисления СВ ---

	//----------------------------------------------------------------
	//--- Вычисление числа попаданий св в интервалы ------------------
	tmp=float((y_max-y_min)/n_i);

	//*** Обнуление массива и задание первоначальных значений ********
	for (i=0, tmp2=0; i<n_i; i++, tmp2+=tmp) {
		mas_i[0][i]=tmp2;
		mas_i[1][i]=tmp2+tmp;
		mas_i[2][i]=0;
	}
	//****************************************************************
	
	for (i=0; i<n_v; i++) {
		for (j=0; j<n_i; j++) {
			if ((mas_sv[i]>=mas_i[0][j])&&(mas_sv[i]<mas_i[1][j])) {
				mas_i[2][j]++;
				break;
			}
		}
	}
	//--- Конец вычисления числа попаданий св в интревалы ------------
	//----------------------------------------------------------------

	//----------------------------------------------------------------
	//--- ВЫВОД в файл func3_fun.txt ---------------------------------
	//----------------------------------------------------------------
	//-- Первый столбец = нижняя граница интервла	                --
	//-- Второй столбец = верхняя граница интервла	                --
	//-- Третий столбец = количество св попавших в интервал			--
	//----------------------------------------------------------------
	if((f2=fopen("func3_fun.txt","w"))==NULL) {
		printf("NO!!!\n");
	} else {
		for(i=0; i<n_real; i++) {
			fprintf(f2,"%f %f\n", mas_y[0][i],mas_y[1][i]);
		}
		fclose(f2);
	}
	//--- КОНЕЦ ВЫВОДА в файл func3_fun.txt --------------------------
	//----------------------------------------------------------------

	//----------------------------------------------------------------
	//--- ВЫВОД в файл func3_sv.txt ----------------------------------
	//----------------------------------------------------------------
	//-- Первый столбец = нижняя граница интервла	                --
	//-- Второй столбец = верхняя граница интервла	                --
	//-- Третий столбец = количество св попавших в интервал			--
	//----------------------------------------------------------------
	if((f3=fopen("func3_sv.txt","w"))==NULL) {
		printf("NO!!!\n");
	} else {
		for(i=0; i<n_i; i++) {
			fprintf(f3,"%f %f %f\n", mas_i[0][i],mas_i[1][i],mas_i[2][i]);
		}
		fclose(f3);
	}
	//--- КОНЕЦ ВЫВОДА в файл func3_sv.txt ---------------------------
	//----------------------------------------------------------------

	//----------------------------------------------------------------
	//--- ВЫВОД в файл func3_first50.txt -----------------------------
	//----------------------------------------------------------------
	//-- Первые 50 случайных величин ---------------------------------
	if((f3=fopen("func3_first50.txt","w"))==NULL) {
		printf("NO!!!\n");
	} else {
		for(i=0; i<50; i++) {
			fprintf(f3,"%f\n", mas_sv[i]);
		}
		fclose(f3);
	}
	//--- КОНЕЦ ВЫВОДА в файл func3_first50.txt ----------------------
	//----------------------------------------------------------------

	//----------------------------------------------------------------------------------
	//--- Вычисление по КОЛМОГОРОВУ ----------------------------------------------------

	for (i=0; i<n_real; i++) {
		mas_fy_sv[0][i]=mas_fy[0][i];
		mas_fy_sv[1][i]=mas_fy[1][i];
		mas_fy_sv_count[i]=0;
	}
	for (i=0; i<n_v; i++) {
		for (j=0; j<n_real; j++) {
			if ((mas_sv[i]>=mas_fy_sv[0][j])&&(mas_sv[i]<mas_fy_sv[1][j])) {
				mas_fy_sv_count[j]++;
				break;
			}
		}
	}
	for (i=0, j=0, tmp=0; i<n_real; j+=mas_fy_sv_count[i], i++) {
		tmp=float(mas_fy_sv_count[i]+j);
		tmp/=n_v;
		mas_fy_sv[2][i]=tmp;
	}
	//*** Сравнение ***************************************************************
	for (i=0, kolm=0, tmp=0; i<n_real; i++) {
		tmp=float(fabs(mas_fy_sv[2][i]-mas_fy[2][i]));
		if (tmp>kolm) {
			kolm=tmp;
		}
	}
	//*****************************************************************************

	//--- Конец вычисления по КОЛМОГОРОВУ -----------------------------------------
	//-----------------------------------------------------------------------------

	//--- РЕЗУЛЬТАТ ПО КОЛМОГОРОВУ в файл kolm.txt ---
	if((f4=fopen("kolm.txt","w"))==NULL) {
		printf("NO!!!\n");
	} else {
		fprintf(f4,"Максимальное отклонение по КОЛМОГОРОВУ = %f \n",kolm);
		fprintf(f4,"Объем выборки = %d \n",n_v);
		//fprintf(f4,"Количество интервалов = %d \n",n_real);
		fclose(f4);
	}
	//--- КОНЕЦ РЕЗУЛЬТАТА ПО КОЛМОГОРОВУ в файл kolm.txt ---

	//*******************************************************************************
	//*** Вычисление по ПИРСОНУ *****************************************************

	//****  Вариант 1  ************
	// n_v					->	N
	// n_real-1				->	M
	// mas_integr[2][k]		->	Pk  
	// mas_fy_sv_count[k]	->	Nk
	//*****************************
	/*
	for (i=1, pirs=0, tmp=0; i<n_real; i++) {
		tmp=n_v*mas_integr[2][i];
		pirs+=float(pow((mas_fy_sv_count[i]-tmp),2)/tmp);
	}
	*/

	//****  Вариант 2  ************
	// n_v					->	N
	// n_i					->	M
	// mas_i[3][n_i]		->	Nk
	// mas_i_Pk[3][n_i]		->	Pk ; для формирования исп-ся -> mas_integr[3][n_real]; 
	//*****************************

	for (i=0; i<n_i; i++) {
		mas_i_Pk[0][i]=mas_i[0][i]; 
		mas_i_Pk[1][i]=mas_i[1][i];
		mas_i_Pk[2][i]=0;
	}

	for (i=0, j=0; i<n_real; i++) {
		if (mas_integr[1][i]>mas_i_Pk[1][j]) {
			j++;
		}
		mas_i_Pk[2][j]+=mas_integr[2][i];
	}
	
	for (i=1, pirs=0, tmp=0; i<n_i; i++) {
		tmp=n_v*mas_i_Pk[2][i];
		pirs+=float(pow((mas_i[2][i]-tmp),2)/tmp);
	}

	if((f5=fopen("pirs.txt","w"))==NULL) 
	{
		printf("NO!!!\n");
	} else {
		fprintf(f5,"Величина ХИ-квадрат для критерия согласия Пирсона = %f \n",pirs);
		fprintf(f5,"Объем выборки = %d \n",n_v);
		fprintf(f5,"Количество карманов = %d \n",m_real);
		fprintf(f5,"Количество интервалов = %d \n",n_i);
		fclose(f5);
	  }

	//*** Конец Вычисления по Пирсону ***********************************************
	//*******************************************************************************


	//----------------------------------------------------------------
	//--- ВЫВОД в файл func3_sv_parent.txt ---------------------------
	//----------------------------------------------------------------
	//-- Первый столбец = нижняя граница интервла	                --
	//-- Второй столбец = верхняя граница интервла	                --
	//-- Третий столбец = количество св попавших в интервал			--
	//----------------------------------------------------------------
	if((f2=fopen("func3_sv_parent.txt","w"))==NULL) {
		printf("NO!!!\n");
	} else {
		for(i=0; i<n_i; i++) {
			fprintf(f2,"%f %f %f \n", mas_i_Pk[0][i], mas_i_Pk[1][i], mas_i_Pk[2][i]);
		}
		fclose(f2);
	}
	//--- КОНЕЦ ВЫВОДА в файл func3_sv_parent.txt --------------------
	//----------------------------------------------------------------
}