Далее поговорим о том, как я проводил взвешенную линейную регрессию. Для этого я просто вычислил среднеквадратические отклонения результатов работы нейросети, а затем поделил на них единицу. Вот исходный код программы, с помощью которой я это сделал:

#include 
#include 
#include 
int main(void)
{
	int i;
	FILE *input,*output;
	while (fopen("input.txt","r")==NULL)
		i=0;
	input = fopen("input.txt","r");//У меня результаты для каждого основания были в отдельном файле.
	double mu,sigma,*x;
	mu=0;
	sigma=0;
	while (malloc(1000*sizeof(double))==NULL)
		i=0;
	x = (double *) malloc(sizeof(double)*1000);
	fscanf(input,"%lf",&mu);
	mu=0;
	for (i=0;i<1000;i++)
	{
		fscanf(input,"%lf",x+i);
	}
	for (i=0;i<1000;i++)
	{
		mu = mu+(*(x+i));
	}
	mu = mu/1000;
	while (fopen("WLS.txt","w") == NULL)
		i=0;
	output = fopen("WLS.txt","w");
	for (i=0;i<1000;i++)
	{
		sigma = sigma + (mu - (*(x+i)))*(mu - (*(x+i)));
	}
	sigma = sigma/1000;
	sigma = sqrt(sigma);
	sigma = 1/sigma;
	fprintf(output,"%10.9lfn",sigma);
	fclose(input);
	fclose(output);
	free(x);
	return 0;
};

Далее я добавил получившиеся веса в таблицу, куда свёл все данные, полученные в результате работы программы, а также значения переменных для вычисления регрессии, а затем вычислил её в JASP. Вот результаты:

Results

Linear Regression

Далее у меня идёт гистограмма плотности распределения стандартизированных остатков регрессии:

А также нормальный квантиль-квантильный график стандартизированных остатков регрессии:

Затем я применил средние значения коэффициентов регрессии, получившиеся в её ходе, к переменным, и провёл свой статистический анализ по поиску наиболее вероятного минимума функции ошибки от основания системы счисления (насколько она связана с этими переменными), используя лемму Ферма, теорему Байеса и теорему Лагранжа следующим образом:
Дело в том, что распределение оснований системы счисления в выборке было заведомо равномерным, поэтому, если некое основание в промежутке (1,2;2) — минимум среднеквадратической ошибки, то так как по лемме Ферма она будет иметь нулевую производную, то плотность вероятности значений функции будет бесконечной. Тогда по теореме Байеса вычисляем бета-распределение функции распределения значений функции среднеквадратичных ошибок от основания, вычисляем её [функции распределения] доверительные интервалы в 99% в каждом значении функции среднеквадратических ошибок, а затем вычисляем доверительные интервалы уже в 98% (используем поправку Бонферрони) разницы между каждым значением функции распределения и значением в минимуме значения функции среднеквадратичных ошибок от основания системы счисления, затем делим крайние точки этого интервала на разницу между соответствующими аргументами функции распределения, и по теореме Лагранжа производная функции распределения в интервале между этими аргументами должна равняться хоть в одной точке получившемуся значению. Но эта производная и есть плотность вероятности, поэтому её максимум должен быть не меньше максимума из получившихся значений. Вот код программы, которой я этот анализ проводил, с пояснениями:

#include "main.h" //Включаем заголовочный файл.
int main(void)
{
	FILE *input,*output;
	int i,n,k,dFmax;
	double *x,*y,*F1,*F2,*F,*dF,*dF1,*dF2,t1,t2,xmin,xmax,ymin,ymax;
	t1=0;
	t2=0;
	while ((input=fopen("input.txt","r"))==NULL)
		i=0;
	while ((output=fopen("output.txt","w"))==NULL)
		i=0;
	n=0;
	while (fscanf(input,"%i",&n)==NULL)
		i=0;
	while ((x = (double *) malloc(sizeof(double)*n))==NULL) //Массив для оснований системы счисления.
		i=0;
	while ((y = (double *) malloc(sizeof(double)*n))==NULL) //Массив для ошибок, вычисленных по коэффициентам.
		i=0;
	while ((F = (double *) malloc(sizeof(double)*n))==NULL) //Массив для медиан бета-функции функции распределения ошибок.
		i=0;
	while ((F1 = (double *) malloc(sizeof(double)*n))==NULL) //Массив для левых концов доверительных интервалов бета-распределений.
		i=0;
	while ((F2 = (double *) malloc(sizeof(double)*n))==NULL)//Массив для правых концов доверительных интервалов бета-распределений.
		i=0;
	for (i=0;i(*(dF1+dFmax)))&&((*(dF2+i))>(*(dF2+dFmax))))
			dFmax=i;
	}
	xmin=0;
	xmax=0;
	ymin=0;
	ymax=0;
	xmin=(*x);
	xmax=(*x);
	ymin=(*y);
	ymax=(*y);
        //Вычисляем промежутки в, которых лежат минимальное значение функции распределения ошибок, и аргумент этой функции, от которого она имеет это значение:
	for (i=0;i<=dFmax;i++)
	{
		if ((*(x+i))>xmax)
			xmax=(*(x+i));
		if ((*(x+i))ymax)
			ymax=(*(y+i));
		if ((*(y+i))

#include 
#include 
#include 
int main(void);
double Bayesian(int n, int m, double x);//Вычисляем плотность вероятности бета-распределения  с n "успехами" и m "неудачами", в нашем случае это "значение случайной величины не больше" и "значение случайной величины больше" точки, в которой вычисляется функция распределения:
double Bayesian(int n, int m, double x)
{
	double c;
	c=(double) 1;
	int i;
	i=0;
	for (i=1;i<=m;i++)
	{
		c = c*((double) (n+i)/i);
	}
	for (i=0;i