Среда программирования для Windows 7

//#include <vcl.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
 
 
 
int main(void)
{
 int indeks, T1;
 double *x_x, *summ, *setka,*disper;
 double alfa1, alfa2, ksi;
 long double y1_n,y2_n, y3_n, y4_n;
 long double y1_l,y2_l, y3_l, y4_l;
 int  r;
 double nach_y1, nach_y2, nach_y3, nach_y4;
 double h,h1;
 double pi;
 double sigma1, sigma2, sigma3;
 double lambda, ww, aa, bb, pp, sigma;
 long int N,M,N1,N2, N1_1,N2_2;
 double A,B;
 int hag, hag1,hag2,hag3 ,T, *count;
 double *setka3_0, *setka3_1, *setka2_0, *setka2_1, *setka4;
 int *count2, *count1, *new_count3;
 double const3,const4, const1,const2,const0, const5;
 double C,D,C1,D1;//границы сетки для построения ЧФП
 double a,b,a1,b1;//границы сетки для построения дмумерной плотности
 double MIN, MAX, MIN1, MAX1;
 double minn,maxx,minn1,maxx1;
 double min, max;
 double a2,b2;//границы сетки для построения ЧИК
 long int *count3;
 int t;
 
           /*---------ВВод начальных данных-----------*/
 h=0.001;
 h1=0.01;
 N= 100000;// T=h*N=100
 N1=70000; // T1=70
 N2=90000;// T2=90
 N1_1=7000;
 N2_2=9000;
 t=N1_1+1;
 
 M=10000;
 sigma1=0.1;
 sigma2=0.01;
 sigma3=0.001;
 nach_y1=1;
 nach_y2=0;
 nach_y3=0;
 nach_y4=0;
 r=24;
 pi= 2*asin(1.0);
 lambda=0.01;
 ww=2;
 aa=0.01;
 bb=10;
 pp=2;
 sigma=0.1;
 
//--------------------------------------------------------------------------
 
 hag=300;  //колличество интервалов разбиения для построения гистограммы
 A=-100;
 B=100;
 
 C=-40; //параметры сетки для построения ЧФП
 D=40;
 
 C1=-40;
 D1=40;
 hag2=8000;//колличество интервалов разбиения для ЧФП
 
 a=-20;//параметры сетки для построения совместной плотности
 b=20;
 
 a1=-20;
 b1=20;
 hag1=4000; //колличество интервалов разбиения для построения совместной плотности
 
 a2=-40;//границы сетки для ЧИК
 b2=40;
 hag3=8000;
//---------------------------------------------------------------------------
 
  int razmer1=hag2*hag2;//Размер матрицы для ЧФП
  int razmer=hag1*hag1; //Размер матрицы для совместной плотности
 
  const0=double((B-A)/hag);
 
  const1=double((b-a)/hag1);
  const2=double((b1-a1)/hag1);
 
  const3=double((D-C)/hag2);
  const4=double((D1-C1)/hag2);
 
  const5=double((b2-a2)/hag3);
           /*-----------------------------------------*/
 
 
 
 //summ =(double*)malloc(N*sizeof(double));//Массив для вторых моментов
 //x_x = (double*)malloc(N*sizeof(double));//Массив для расчета матожидания
 //disper = (double*)malloc(N*sizeof(double));//Массив для расчета дисперсии
 
 count2= (int*)malloc(razmer1*sizeof(int));//Матрица для заполнения ЧФП
 
 count1= (int*)malloc(razmer*sizeof(int));//Матрица для заполнения совместной плотности
 
 count=(int*)malloc(hag*sizeof(int));  //Массив со значениями одномерной гистограммы
 
 setka=(double*)malloc(hag*sizeof(double));//Сетка для одномерной гистограммы
 
 setka3_0=(double*)malloc(hag2*sizeof(double));//2 сетки для построения ЧФП
 setka3_1=(double*)malloc(hag2*sizeof(double));//
 
 setka2_0=(double*)malloc(hag*sizeof(double));//2 сетки для построения совместной плотности
 setka2_1=(double*)malloc(hag*sizeof(double));//
 
 setka4=(double*)malloc(hag3*sizeof(double));//создание сетки для ЧИК
 
   /*   for (int i = 0; i < N; i++)//Обнуление массивов
         {
 
                summ[i]=0;
                x_x[i]=0;
         }    */
 
                y1_n=0;
                y2_n=0;
                y3_n=0;
                y4_n=0;
 
                y1_l=0;
                y2_l=0;
                y3_l=0;
                y4_l=0;
 
 
    for (int k = 0; k < razmer1; k++)
      count2[k]=0;
 
    for (int i=0; i<razmer; i++)
       count1[i]=0;
 
    for (int i = 0; i < hag; i++)
       count[i]=0;
 
 
 
/*----------------ВВод значений в нуливой узел и создание сеток-------------------*/
 
     //  x_x[0] = x_x[0]+y1_l/M;
     //  summ[0]=summ[0]+(double)(y1_l*y1_l)/M;
    //   disper[0]=summ[0]-(x_x[0]*x_x[0]);
 
       setka[0]=A;
 
       setka2_0[0]=a;
       setka2_1[0]=a1;
 
       setka3_0[0]=C;
       setka3_1[0]=C1;
 
       setka4[0]=a2;
 
    for (int j = 0; j < hag2; j++)
    {
        setka3_0[j+1]=setka3_0[j]+const3;
        setka3_1[j+1]=setka3_1[j]+const4;
    }
 
    for (int j = 0; j < hag1; j++)
    {
        setka2_0[j+1]=setka2_0[j]+const1;
        setka2_1[j+1]=setka2_1[j]+const2;
    }
 
     for (int j = 0; j < hag; j++)
          setka[j+1]=setka[j]+const0;
 
     for (int j = 0; j < hag3; j++)
        setka4[j+1]=setka4[j]+const5;
 
/*---------------------------------------------------------------*/
 
       minn=y1_l;
       maxx=minn;
       minn1=y3_l;
       maxx1=minn1;
 
       MIN=y1_l;
       MAX=MIN;
       MIN1=y3_l;
       MAX1=MIN1;
 
      int X2,Y2;
 
      int X,Y;
      X=hag1;
      Y=hag1;
 
      int X1=hag;
      int X3=hag3;
      int Y3=0;
      
 
      int P;
      int new_razmer2;
 
      P=10;//h1/h
      new_razmer2= (N2_2-N1_1)*hag3;
 
      new_count3= (int*)malloc(new_razmer2*sizeof(int));//итоговый массив-матрица, для построения графика ЧИК
 
      for (int i=0; i<new_razmer2; i++)
         new_count3[i]=0;
 
 
      indeks=1;
      T1=P;
 
        FILE * date_y1;
    FILE * date_y2;
    date_y1 = fopen("Данные_Y1.txt","w");
    date_y2 = fopen("Данные_Y2.txt","w");
    
 
 
      for(int j = 0; j < M; j++)//цыкл для моделирования M штук траекторий
          {
 
               y1_l = nach_y1;
               y2_l = nach_y2;
               y3_l = nach_y3;
               t=N1_1;
 
             X2= (int) ((y1_l-C)/const3);
             Y2= (int) ((y2_l-C1)/const4);
             count2[X2+Y2*hag2]= count2[X2+Y2*hag2]+1;
 
 
 
            for(int i=0; i<N; i++)//цыкл для моделирования 1 траектории
         {
 
                alfa1 = (double)rand()/(double)RAND_MAX;
                while(alfa1 == 0)
                alfa1 = (double)rand()/(double)RAND_MAX;
                alfa2 = (double)rand()/(double)RAND_MAX;
                ksi = sqrt(-2*log(alfa1))*sin(2*pi*alfa2);//моделирование гаусовской случайной величины
 
                                y1_n = y1_l+y2_l*h;
                                y2_n = y2_l-(lambda*y2_l+ww*ww*y1_l+aa*y1_l*y1_l*y1_l+bb*sin(pp*i*h))*h+sigma*(sqrt(h))*ksi;
 
                                if(j==10)
                                {
                                  fprintf( date_y1, "%f " , y1_n );
                                  fprintf( date_y2, "%f " , y2_n );
                            }
 
 
 
 
              //    x_x[i+1]=x_x[i+1]+y1_n/M; //Расчитывается оценка математического ожидания
              //    summ[i+1]=summ[i+1]+(double)(y1_n*y1_n)/M;//Расчитывается второй момент
              //    disper[i+1]=summ[i+1]-(x_x[i+1]*x_x[i+1]);//рассчитывается Дисперсия
 
 
 
                X2= (int) ((y1_n-C)/const3);
                Y2= (int) ((y2_n-C1)/const4);
 
                count2[X2+Y2*hag2]= count2[X2+Y2*hag2]+1;
 
 
            if ((i>N1) && (i<N2))//цикл для заполнения ЧИК
              {
 
                X3=(int)((y2_n-a2)/const5);
                Y3=(int) ((i-N1-1)/P);
                new_count3[X3+Y3*hag3]=new_count3[X3+Y3*hag3]+1;
 
              }
 
 
 
 
 
                y1_l=y1_n;
                y2_l=y2_n;
                
 
            if (y1_n<minn)//Нахождение минимального и максимального эдемента в массивах y1 и y2, для масштабирования
            {
             minn=y1_n;
            }
 
            if (y1_n>maxx)
            {
            maxx=y1_n;
            }
 
            if (y2_n<minn1)
            {
             minn1=y2_n;
            }
 
            if (y2_n>maxx1)
            {
            maxx1=y2_n;
            } 
 
       }
 
 
            X1= (int) ((y2_n-A)/const0); //заполнение гистограммы
              count[X1]=count[X1]+1;
 
            X= (int) ((y1_n-a)/const1);  //заполнение совместной плотности
            Y= (int) ((y2_n-a1)/const2);
            count1[X+Y*hag1]= count1[X+Y*hag1]+1;
 
 
 
    /*       if (y1[N-1]<MIN)//нахождение максимального и минимального элемента в узле [N-1], для масштабирования
        {
             MIN=y1[N-1];
        }
 
        if (y1[N-1]>MAX)
        {
            MAX=y1[N-1];
        }
 
        if (y3[N-1]<MIN1)
        {
             MIN1=y3[N-1];
        }
 
        if (y3[N-1]>MAX1)
        {
            MAX1=y3[N-1];
        }/*   
 
 
 
      /*    for( int i = N1_1+1; i < N2_2; i++ )
        {
                   for( int k = 0; k < hag3; k++ )
                   {
            for( int j = 0; j < P; j++ )
 
              {
               new_count3[k+hag3*(i-N1_1-1)]=new_count3[k+hag3*(i-N1_1-1)]+count3[k+hag3*(i-N1_1)*j];
              }
           }
        } */
 
 
        }
 
         fclose(date_y1);
     fclose(date_y2);
 
 
/*-------------------Вывод в файл всех необходимых переменных--------------------*/
 
 //---------------------вывод сетки для ЧИК-----------------------------
    FILE * SETKA3_0;
 
     SETKA3_0 = fopen("4fp.txt","w");
            for (int i = 0; i <hag2; i++)
                  {
            for (int j = 0; j <hag2; j++)
            {
             fprintf(SETKA3_0, "%f   %f   %d\n", setka3_0[i], setka3_1[j], count2[j+i*hag2]);
             }
                           fprintf( SETKA3_0, "\n");
          }
     fclose(SETKA3_0);
 
 
//--------------------вывод данных для совместной плотности-----------------------
 
     FILE * SETKA2_0;
 
     SETKA2_0 = fopen("sovmPL.txt","w");
 
                for (int i = 0; i <hag1; i++)
                 {
                for (int j = 0; j <hag1; j++)
                {
                fprintf( SETKA2_0, "%f   %f   %d\n", setka2_0[i], setka2_1[j], count1[j+i*hag1] );
                }
               fprintf( SETKA2_0, "\n");
         }
     fclose(SETKA2_0);
 
//---------------------вывод сетки для ЧИК-----------------------------
 
 
      FILE * SETKA_vremya; // задаем сетку по времени необходимую для расчета
 
       SETKA_vremya = fopen("4ik.txt","w");
        for (int i =N1_1+1; i <N2_2; i++ )
             {
        for (int j = 0; j <hag3; j++ )
          {
          fprintf( SETKA_vremya, "%f   %f   %d\n" , setka4[j], (double)(i*h1), new_count3[j+hag3*(i-N1_1-1)]);
          }
              fprintf( SETKA_vremya, " \n");
                  }
 
     fclose(SETKA_vremya);
 
 
//------------------вывод матрицы и вывод сетки для одномерной гистограммы-------------------------
 
     FILE * odnomernaya_gistogramma;
 
     odnomernaya_gistogramma = fopen("gistogr.txt","w");
 
     for (int i = 0; i <hag; i++)
      {
 
     fprintf( odnomernaya_gistogramma, "%f %d\n" , setka[i], count[i] );
 
      }
 
     fclose(odnomernaya_gistogramma);
 
   //------------------вывод: матожидания, дисперсии, фазовых траекторий----------------------------
    
    FILE * matogidanie;
    FILE * dispersiya;
    FILE * razbienie;
    matogidanie = fopen("матожидание.txt","w");
    dispersiya = fopen("Дисперсия.txt","w");
    razbienie = fopen("ось_абсцисс.txt","w");
     for (int i = 0; i <N; i++)
      {
   //    fprintf( date_y1, "%f " , y1[i] );
   //    fprintf( date_y2, "%f " , y2[i] );
  //     fprintf( date_y3, "%f " , y3[i] );
//   fprintf( dispersiya , "%f " , disper[i] );
  //     fprintf( matogidanie, "%f " , x_x[i] );
  //     fprintf( razbienie, "%f " , h*i );
 
      }
     fclose(date_y1);
     fclose(date_y2);
     //fclose(date_y3);
     fclose(matogidanie);
     fclose(dispersiya);
     fclose(razbienie);
 
 
   //Вывод вспомогательного файлся со значениями максимумов для масштабирования
 
        FILE * vspomogatel;
        vspomogatel = fopen("Масштабирование.txt","w");
        fprintf( vspomogatel, "%f " ,  minn);
        fprintf( vspomogatel, "%f " ,  maxx);
        //fprintf( vspomogatel, "\n");
        fprintf( vspomogatel, "%f " ,  minn1);
        fprintf( vspomogatel, "%f " ,  maxx1);
        //fprintf( vspomogatel, "\n");
        fprintf( vspomogatel, "%f " ,  MIN);
        fprintf( vspomogatel, "%f " ,  MAX);
        //fprintf( vspomogatel, "\n");
        fprintf( vspomogatel, "%f " ,  MIN1);
        fprintf( vspomogatel, "%f " ,  MAX1);
        //fprintf( vspomogatel, "\n");
        fclose(vspomogatel);
                                                                      
 
 
 
 
 
    free(count2);
    free(count1);
    free(count);
    //free(count3);
        free(new_count3);
 
    free(setka);
    free(setka3_0);
    free(setka3_1);
    free(setka2_0);
    free(setka2_1);
    free(setka4);
return(0);
}
//---------------------------------------------------------------------------