// 01.10.2014. Авторские и имущественные права на программный код
// переданы А.Е.Акимову-Тимьянову как одному из основных соавторов
// со всеми вытекающими из этого правами для развития его научно-
// исследовательской работы в НИИММ при МГУ. Текущая версия
// объявляется последней, распространяемой как freeware OpenSource GNU PL.
// Дальнейшие версии неидентифицируются и не подлежат распространению
// иначе как с согласия правопреемников В.В.Пекунова, оставляюего за собой
// право на модернизацию кода в лично научных и иных некоммерческих целях,
// и правообладателя.

// Для компиляции требуется предварительная обработка файла
// транслятором процедур с повторным входом (можно скачать
// с сайта автора архив Reenterable.zip, размещенный по
// ссылке http://pekunov.chat.ru/Progs/Reenterable.zip
// Транслятор компилируется в Lazarus или с помощью Free Pascal.
// Далее обрабатываем программу: Reenterable.exe Modelling.cpp run.cpp
// Компилируем run.cpp и запускаем результат.

// To compile this program it is necessarry to handle its file
// by means of reenterable procedures preprocessor (you can get it
// from the archive Reenterable.zip at the author site. The link:
// http://pekunov.chat.ru/Progs/Reenterable.zip
// Preprocessor can be built by Lazarus or Free Pascal of the last versions.
// Start preprocessing using command: Reenterable.exe Modelling.cpp run.cpp
// Then compile please run.cpp and execute the result.


/* V0.981 beta2. 14.08.2014.
   Почти полноценная версия. Не хватает лишь подсчета времени по модели. */

// Сброс данных в файл, во избежание. XML???
// Индукция лин. классиф. правил, вероятностей.
// Время -- !!!
// map<set,Rule> -- кэш для правил.
// set<Rule> -- для выделения общих частей, например.
// голосование за дуги???
// Фильтрация значений. Взаимные ссылки.
// introducevar(name,expression)
// Сейчас может быть что-то не так при счете с компиляцией и без. Типы? Пороги?

// Порог 0.1. Сделать настраиваемым в модели. В системе -- увеличить или уменьшить?

// Расчет порогов вероятностей в зависомости от входных переменных.
// Интерполяция векторов данных по входным данным и параметрам алгоритма. Промежуточных
// или конечных. Вешать ее на дуги!!!

// post-conditioning
// + Еще один вариант -- автоматически вешать RegisterVariable на индукцию по следующей дуге,
//   если она введена не до появления модели, конечно.
// + interpret induct funcs...
// + fun[i]==null!!! point into loop!!! Register with parameter -- induct!!!
// + Перестал работать FindRelation с пустым Declined
// + Проверить формулы для исключаемой переменной...
// + entry/exit -- паразитные переходы
// + Интерполятор дает неверные значения!!! Diff-модель.
// Советы RegisterVariable -- by means of which function we shall predict? sin,cos,log,... LIST
// + Порядок для RegisterVar при индукте!!! Иначе нет логики в зависимостях!!!
// getValue() -- conditioning
// _N/=10 -- 3 points -- problems with correlations???
// CUDA. Построение модели, работа модели. Параллельный обсчет МГУА, например. Полином?
//   Завсисмости по данным надо учесть.

#include "metalyer-p.h"

using namespace std;

// extern void cudaGetLU(int NN, int * iRow, float * LU);


void Subroutine() {
//  MarkModelPoint("Subroutine");
}

int MAIN();

int main() {
  map<string,HMODULE>::iterator iLibs;
  int result = MAIN();
  FreeModel();
  for (iLibs = Libs.begin(); iLibs!=Libs.end(); iLibs++)
      FreeLibrary(iLibs->second);
  return result;
}

typedef __declspec(dllimport) double (*MyModel)(double ___min, double ___max, int &_N);
typedef __declspec(dllimport) double (*GearModel)(double ___min, double ___max, int &_j);
typedef __declspec(dllimport) double (*MatrixModel)(double ___min, double ___max, double &_N);
typedef __declspec(dllimport) double (*DiffModel)(double ___min, double ___max, double &_X, double &_Y);
typedef __declspec(dllimport) double (*DiffModelN)(double ___min, double ___max, int &_N, double &_X, double &_Y);
typedef __declspec(dllimport) double (*LastModel)(double ___min, double ___max, double &_N);

#define main MAIN

// #include "kinetic.h"

void QuickSort(int * a, int Left, int Right)
{
 int i,j,p,s;;
 i=Left; j=Right; p=a[(Left+Right) / 2];
 do {
   while (a[i]<p) i++;
   while (p<a[j]) j--;
   if (i<=j)
     {
      s=a[i]; a[i]=a[j]; a[j]=s;
      i++; j--;
     }
 } while (i<=j);
 if (Left<j) QuickSort(a,Left,j);
 if (i<Right) QuickSort(a,i,Right);
}

/*void SolveT(int p, float * T);

const int NNNB = 6;
const int NNN1 = 32+2;
const int NNN2 = 16+2;

void _Therm(float * T) {
 const float TAU = 0.0001;
 const float A2  = 0.1;
 const float H   = 0.5;

 float T1[NNN1][NNN2];

 float D = TAU*A2/H/H;
 
 memmove(T1,T,sizeof(T1));
 for (int i=0; i<40000; i++) {
   for (int y=1; y<NNN1-1; y++)
     for (int x=1; x<NNN2-1; x++)
       T1[y][x] = T[y*NNN2+x]+D*(T[(y-1)*NNN2+x]+T[(y+1)*NNN2+x]+T[y*NNN2+x-1]+T[y*NNN2+x+1]-4*T[y*NNN2+x]);
   memmove(T,T1,sizeof(T1));
 }
}
*/

vector<double> V0(100), V1(100), Z(100);

reenterable ModelLoop(int _N, double & X) {
  if (_N <= 100) {
     StartModel();
     RegisterVariable("N",_N);
     X=200.0;
     RegisterVariable("X",X,true);
     for (int i=0; i<_N; i++) {
        X += 0.1*(-(V0[i] = X));
     }
     RegisterVariable("Y",X,true);
     plan_last(_N*2, X);
  }
}

int main() {
/*  double TT;
  float TTT0[NNNB*NNN1*NNN2];
  memset(TTT0,0,NNNB*NNN1*NNN2*sizeof(float));
  for (int i=0; i<NNN2*NNN1*NNNB; i++)
      TTT0[i] = 10.0*rand()/RAND_MAX;
  float TTT[NNNB*NNN1*NNN2];
  for (int p=1; p<=NNNB; p++) {
      for (int k=0; k<5; k++) {
          if (k==1) TT = milliseconds();
          memmove(TTT,TTT0,NNNB*NNN1*NNN2*sizeof(float));
          SolveT(p,TTT);
      }
      cout<<"CUDA["<<p<<"] = "<<(milliseconds()-TT)/4.0<<endl;
  }
  float TTT1[NNNB*NNN1*NNN2];
  for (int p=1; p<=NNNB; p++) {
      for (int k=0; k<5; k++) {
          if (k==1) TT = milliseconds();
          memmove(TTT1,TTT0,NNNB*NNN1*NNN2*sizeof(float));
          for (int i=0; i<p; i++)
              _Therm(&TTT1[i*NNN1*NNN2]);
      }
      cout<<"CPU["<<p<<"] = "<<(milliseconds()-TT)/4.0<<endl;
  }
//  double err = 0.0;
//  for (int k=0; k<NNNB*NNN1*NNN2; k++)
//      err+=fabs(TTT[k]-TTT1[k]);
//  cout<<err<<endl;
/*
  int iR[50];
  float Q[50][50];
  float LU[50][50]; // cudaHostAlloc!!! Map... 
  for (int i=0; i<50; i++)
    for (int j=0; j<50; j++)
      Q[i][j] = 1.0*rand()/RAND_MAX;
  for (int k=0; k<5; k++) {
      if (k==1) TT = milliseconds();
      for (int i=0; i<50; i++)
        for (int j=0; j<50; j++)
          LU[i][j] = Q[i][j];
      cudaGetLU(50,iR,(float *) LU);
  }
  cout<<(milliseconds()-TT)/4.0<<endl;
  int _iR[50];
  long double _LU[50][50], _AA[50][50];
  for (int k=0; k<5; k++) {
      if (k==1) TT = milliseconds();
      for (int i=0; i<50; i++)
        for (int j=0; j<50; j++)
          _AA[i][j] = Q[i][j];
      pm::_GetLU(50,_iR,(long double *) _AA,(long double *) _LU);
  }
  cout<<(milliseconds()-TT)/4.0<<endl;
*/

  int N;
  double T = 0.0;
  for (N = 3; N<6; N++) {
    //double timer = milliseconds();
    StartModel();
    RegisterVariable("N",N);
//    CreateContext("Main",2,"N","Bool1");
    MarkModelPoint("Bool", true);
    for (int j=0; j<8; j++) {
      MarkModelPoint("Bool1", true);
      for (int i=0; i<N; i++)
          {
           MarkModelPoint("BoolLoop", true);
           if (j%2==0 || i==3)
              MarkModelPoint("Bool2", true);
           else
              MarkModelPoint("Bool20", true);
           Subroutine();
           MarkModelPoint("BoolCollect", true);
           if (i == j)
              MarkModelPoint("BoolX", true);
           Sleep(N*N*N-2*j+i); // incorrect context (scope?) or incorrect prediction/measurement??
           Subroutine();
          }
      MarkModelPoint("Bool3", true);
    }
    MarkModelPoint("Boolll", true);
    SwitchContext(defaultContext);
    for (int j=0; j<50; j++) {
        MarkModelPoint("BoomGeom_Start", true);
        if (j==2 || j==4 || j==8 || j==16)
           MarkModelPoint("BoolGeom", true);
    }
    MarkModelPoint("Bool4", true);
    T += pm::ModelTime;
  }
  StopModel();
  // ExportModelToCPP("MyModel","MyModel.cpp");
  char * path = "\"C:\\Program Files\\Microsoft Visual Studio 8\\VC\\bin\";\"C:\\Program Files\\Microsoft Visual Studio 8\\Common7\\IDE\\\"";
  char * ipaths[2] = {"\"C:\\Program Files\\Microsoft Visual Studio 8\\VC\\include\"","\"C:\\Program Files\\Microsoft SDKs\\Windows\\v7.1A\\Include\""};
  char * lpaths[2] = {"\"C:\\Program Files\\Microsoft Visual Studio 8\\VC\\lib\"","\"C:\\Program Files\\Microsoft SDKs\\Windows\\v7.1A\\Lib\""};
  MyModel MODEL;
  if (ExportModelToLibrary("MyModel","MyModel.cpp",path,2,ipaths,2,lpaths))
     MODEL = (MyModel) ImportModel("MyModel","MyModel.dll");
  else
     MODEL = NULL;
  if (!MODEL) cout<<endl<<"Error loading compiled DLL : could not import model"<<endl;
  cout<<endl<<"TIME = "<<T/3.0<<endl;
  for (T = 0, N = 3; N<6; N++) {
    if (MODEL) T += MODEL(1.0,10000.0,N);
    else {
     RegisterVariable("N",N);
     T += ProcessModel();
    }
  }
  cout<<"MODEL = "<<T/3.0<<endl;
  FreeModel();
  // Matrix. if i>j then complex formulae else simple formula
  // Sort. MergeSorst, QuickSort.
  // Task Pool. Load balancing. Moving objects (3D complex scene rendering)
  // Chemistry
  // Database... planning of queries splitting???
  // Complex algorithms with time of execution strongly dependending from data. Independent cells
  // with variing characteristics. Poisson and other equations when f(x,y) is algorithmically calculated
  // Math physics consequently... Overrelaxation
  // In the most cases -- time dependencies from input data will be used
  // In rare cases (complex algorithms) -- algorithm induction can help...
  // Imitative modeling of complex algorithms... Parallelizing, search of optima.

  double Timings[8];

/*
  // Another test
  NSubst = 15; // chislo vezhestv
  NReact = 17; // chislo reaksii
  // Zadaem simvolnie oboznachenie veshestv
  strcpy(Names[0], "CH4");   strcpy(Names[1], "O2");
  strcpy(Names[2], "CH3");   strcpy(Names[3], "HO2");
  strcpy(Names[4], "CH3OO"); strcpy(Names[5], "CH2O");
  strcpy(Names[6], "OH");    strcpy(Names[7], "H2O");
  strcpy(Names[8], "HCO");   strcpy(Names[9], "CO");
  strcpy(Names[10], "H2O2"); strcpy(Names[11], "CO2");
  strcpy(Names[12], "H");    strcpy(Names[13], "H2");
  strcpy(Names[14], "C2H6");
  AllocateKineticByReactions();
  // opredelyaem parametri reakzii
  EA[0] = 55.0;      A[0] = 11.0;    Tn[0] = 0.0;
  EA[1] = 0.0;      A[1] = 8.0;    Tn[1] = 0.0;
  EA[2] = 20.0;       A[2] = 13.0-3.0;    Tn[2] = 0.0;
  EA[3] = 8.5;      A[3] = 11.0;    Tn[3] = 0.0;
  EA[4] = 6.3;      A[4] = 12.0;    Tn[4] = 0.0;
  EA[5] = 32.0;      A[5] = 11.0;    Tn[5] = 0.0;
  EA[6] = 0.0;      A[6] = 8.0;     Tn[6] = 0.0;
  EA[7] = 19.75;       A[7] = 11.0;     Tn[7] = 0.0;
  EA[8] = 8.5;      A[8] = 11.0;    Tn[8] = 0.0;
  EA[9] = 7.0;      A[9] = 11.0;    Tn[9] = 0.0;
  EA[10] = 11.2;      A[10] = 10.1;    Tn[10] = 0.0;
  EA[11] = 2.0;     A[11] = 8.5;    Tn[11] = 0.0;
  EA[12] = 0.0;     A[12] = 10.0;    Tn[12] = 0.0;
  EA[13] = 0.0;     A[13] = 10.0;        Tn[13] = 0.0;
  EA[14] = 0.0;     A[14] = 10.0;     Tn[14] = 0.0;
  EA[15] = 0.0;      A[15] = 10.0;     Tn[15] = 0.0;
  EA[16] = 0.0;      A[16] = 10.0;     Tn[16] = 0.0;
  for (int j=0; j<17; j++)
      A[j]+=3.0;
  // transliruem reaksii
  Translate (0, "CH4+O2->CH3+HO2");    Translate (1, "CH3+O2->CH3OO");
  Translate (2, "CH3OO->CH2O+OH");     Translate (3, "CH4+OH->CH3+H2O");
  Translate (4, "CH2O+OH->H2O+HCO");   Translate (5, "CH2O+O2->HCO+HO2");
  Translate (6, "HCO+O2->CO+HO2");     Translate (7, "CH4+HO2->H2O2+CH3");
  Translate (8, "CH2O+HO2->H2O2+HCO"); Translate (9, "CO+OH->CO2+H");
  Translate (10, "CH4+H->CH3+H2");     Translate (11, "CH2O+H->HCO+H2");
  Translate (12, "2CH3->C2H6");        Translate (13, "2HO2->H2O2+O2");
  Translate (14, "OH+HO2->H2O+O2");    Translate (15, "H+HO2->H2+O2");
  Translate (16, "CH3+HO2->CH4+O2");
  ReTranslate();
  AllocateKineticBySubsts();
  EndTime = 1e-3; // vremya interirovaniya
  Tk = 1300.0;      // Temperatura provediya reaksii v K
  for (int i = 0; i < NASubst; i++)
      Conc0[i] = 0.0;
  
  LossPrecision = 0;
  // nachalnie znacheniya konzentrasii
  for (int j = 0; j<8; j++) {
    Conc0[0] = 1.0*j/19*0.41*1e-4;
    Conc0[1] = 1.0*(19-j)/19*0.71*0.41*1e-4;
    StartModel();
    RegisterVariable("j",j);
//    CreateContext("GEAR",1,"j");
//    T = milliseconds();
    OneTaktKinetic(0,Adams_Rozhkov_Method);
//    T = milliseconds()-T;
    if (LossPrecision)
         {
          cout << " Oshibka vichislenii : " <<
            (KinErrorInfo.LossH==0 ? " slishkom mnogo iterasii" :
            " poterya tochnosti - shag po vremeni stremitcya k nulu ") << "\n";
          cout << " Vichisleniya prervani v moment t=" << KinErrorInfo.ReachTau <<
                ". Vipolnino "<< Iters <<" iterasi\n";
         }
    for (int i=0; i<NASubst; i++)
        Conc0[i] = Conc1[i];
    for (int i = 0; i < NASubst; i++)
        cout << Names[TranMap[i]] << " = " << Conc1[i]/0.41e-4 << " ";
    cout << endl;
    cout<<endl<<"GEAR EXPRM = "<<(Timings[j] = pm::ModelTime)<<endl;
  }
  StopModel();

  ExportModelToCPP("Gear","GearModel.cpp");
  ExportModelToLibrary("GearModel","GearModel.cpp",path,2,ipaths,2,lpaths);
  GearModel GEARMODEL = (GearModel) ImportModel("GearModel","GearModel.dll");
  for (int j = 0; j<8; j++)
    cout<<"GEAR MODEL = "<<GEARMODEL(0.0001,10000.0,j)<<" : eps = "<<fabs((Timings[j]-GEARMODEL(0.0001,10000.0,j))/Timings[j])<<endl;
*/

  //FreeModel();
  //int * Data = new int[800000];
  //for (int _N = 800000; _N>=1; _N /= 2) {
  //    for (int i=0; i<_N; i++) Data[i] = rand();
  //    StartModel();
  //    RegisterVariable("_N",log(1.0*_N)/log(2.0));
  //    MarkModelPoint("Entry", true);
  //    QuickSort(Data,0,_N-1);
  //    MarkModelPoint("Exit", true);
  //}
  //delete[] Data;
  //StopModel();

  //ExportModelToCPP("QS","QS.cpp");
  //ExportModelToLibrary("QS","QS.cpp",path,2,ipaths,2,lpaths);
  //MyModel QSMODEL = (MyModel) ImportModel("QS","QS.dll");
  //for (int _N = 800000; _N>=1; _N /= 2)
  //  cout<<"QS MODEL = "<<QSMODEL(1.0,10000.0,log(1.0*_N)/log(2.0))<<endl;

  FreeModel();
  T = 0.0;
  #pragma omp parallel for num_threads(2) schedule(guided)
  for (int i = 0; i<2; i++) T += cos(1.0*i);

  T = milliseconds();
  for (int j=0; j<10000; j++) {
    milliseconds();
  }
  double callsDelay = (milliseconds()-T)/10001.0;
  T = milliseconds();
  for (int j=0; j<1000; j++) {
      #pragma omp parallel for num_threads(2) schedule(guided)
      for (int i = 0; i<2; i++);
  }
  double OMPDelay = (milliseconds()-T)/1000.0-callsDelay;
  cout<<"OMP loop delay = "<<OMPDelay<<" msec."<<endl;

  const double M_PI = 3.1415926535897932;
  int * Data = new int[800*800];
  
  for (int _N = 800; _N>=1; _N /= 5) {
      StartModel();
      RegisterVariable("_N",0.1*_N);
      //T = milliseconds();
      MarkModelPoint("Entry", true);
      for (int j=0; j<_N; j++) {
          for (int i=0; i<_N; i++) {
              double A = 1.0, B = 5.5, k1 = 0.1, k2 = 0.2, k3 = 0.05, k4 = 0.1;
              double U = 5.0*j/_N;
              double V = 5.0*i/_N;
              double t = 0.0;
              double TMAX = 0.01;
              double tau = 0.001;
              for (; t<TMAX; t+=tau) {
                double U1 = U+tau*(k1*A+k2*U*U*V-k3*B*U-k4*U);
                double V1 = V+tau*(-k2*U*U*V+k3*B*U);
                U = U1;
                V = V1;
              }
              Data[j*_N+i] = U;
          }
      }
      MarkModelPoint("Exit", true);
      //T = milliseconds()-T;
      cout<<"Matrix = "<<pm::ModelTime<<endl;
  }
  StopModel();

  ExportModelToCPP("Matrix","Matrix.cpp");
  ExportModelToLibrary("Matrix","Matrix.cpp",path,2,ipaths,2,lpaths);
  MatrixModel MMODEL = (MatrixModel) ImportModel("Matrix","Matrix.dll");
  for (int _N = 800; _N>=1; _N /= 5) {
    double __N = 0.1*_N;
    cout<<"Matrix MODEL = "<<MMODEL(0.1,10000.0,__N)<<endl;
  }

  for (int _N = 800; _N>=1; _N /= 5) {
      double __N = 0.1*_N;
      int Can = 0.5*MMODEL(0.01,10000.0,__N)>OMPDelay;
      cout<<"Matrix ["<<_N<<","<<_N<<"]. Parallelizing potentially gives "<<(Can ? "best" : "worst")<<" results"<<endl;
      T = milliseconds();
      for (int k = 0; k < min(8000/_N,50); k++) {
        for (int j=0; j<_N; j++)
            for (int i=0; i<_N; i++) {
              double A = 1.0, B = 5.5, k1 = 0.1, k2 = 0.2, k3 = 0.05, k4 = 0.1;
              double U = 5.0*j/_N;
              double V = 5.0*i/_N;
              double t = 0.0;
              double TMAX = 0.01;
              double tau = 0.001;
              for (; t<TMAX; t+=tau) {
                double U1 = U+tau*(k1*A+k2*U*U*V-k3*B*U-k4*U);
                double V1 = V+tau*(-k2*U*U*V+k3*B*U);
                U = U1;
                V = V1;
              }
              Data[j*_N+i] = U;
            }
      }
      T = milliseconds()-T-callsDelay;
      cout<<"SINGLE = "<<T<<endl;
      T = milliseconds();
      for (int k = 0; k < min(8000/_N,50); k++) {
        #pragma omp parallel for num_threads(2) schedule(guided)
        for (int j=0; j<_N; j++)
            for (int i=0; i<_N; i++) {
              double A = 1.0, B = 5.5, k1 = 0.1, k2 = 0.2, k3 = 0.05, k4 = 0.1;
              double U = 5.0*j/_N;
              double V = 5.0*i/_N;
              double t = 0.0;
              double TMAX = 0.01;
              double tau = 0.001;
              for (; t<TMAX; t+=tau) {
                double U1 = U+tau*(k1*A+k2*U*U*V-k3*B*U-k4*U);
                double V1 = V+tau*(-k2*U*U*V+k3*B*U);
                U = U1;
                V = V1;
              }
              Data[j*_N+i] = U;
            }
      }
      T = milliseconds()-T-callsDelay;
      cout<<"PARALLEL = "<<T<<endl;
  }

  delete[] Data;

  double X;
  FreeModel();
//  StartModel(); // error in DLL!!!
  for (int _N=2; _N<=100; _N*=2) {
      StartModel();
      RegisterVariable("N",_N);
      X=200.0;
      RegisterVariable("X",X);
      MarkModelPoint("ENTRY");
      for (int i=0; i<_N; i++) {
        RegisterVariable("X",X,true);
        MarkModelPoint("LOOP");
        X += 0.1*(-(V0[i] = X));
        RegisterVariable("Y",X,true);
        MarkModelPoint("ELOOP");
      }
      MarkModelPoint("EXIT");
      Z[_N-1] = X;
  }
  StopModel();
  ExportModelToCPP("Diff0","Diff0.cpp");
  if (ExportModelToLibrary("Diff0","Diff0.cpp",path,2,ipaths,2,lpaths)) {
     double Y;
     DiffModelN DiffMODEL = (DiffModelN) ImportModel("Diff0","Diff0.dll");
     for (int _N=2; _N<=100; _N*=2) {
       X = 200.0;
       DiffMODEL(0.1,10000.0,_N,X,Y);
       cout<<"Euler with marks : "<<Z[_N-1]-Y<<endl;
     }
  }
  FreeModel();
  ModelLoop(2, X);
  StopModel();
  ExportModelToCPP("Diff1","Diff1.cpp");
  if (ExportModelToLibrary("Diff1","Diff1.cpp",path,2,ipaths,2,lpaths)) {
     double Y;
     DiffModelN DiffMODEL = (DiffModelN) ImportModel("Diff1","Diff1.dll");
     for (int _N=2; _N<=100; _N*=2) {
       X = 200.0;
       DiffMODEL(0.1,10000.0,_N,X,Y);
       cout<<"Euler without marks : "<<Z[_N-1]-Y<<endl;
     }
  }
  FreeModel();
  X = 200.0;
  for (int i=0; i<100; i++) {
    StartModel();
    RegisterVariable("X",X);
    X += 0.1*(-(V0[i] = X));
    RegisterVariable("Y",X,true);
  }
  StopModel();
  ExportModelToCPP("Diff","Diff.cpp");
  if (ExportModelToLibrary("Diff","Diff.cpp",path,2,ipaths,2,lpaths)) {
     DiffModel DiffMODEL = (DiffModel) ImportModel("Diff","Diff.dll");
     X = 200.0;
     for (int i=0; i<100; i++) {
       double Y;
       DiffMODEL(0.1,10000.0,X,Y);
       X += 0.1*(0.5*((-X)+(-Y)));
       V1[i] = X;
     }
     double t = 0.1;
     for (int i=0; i<99; i++) {
       double VAL = 200.0*exp(-(t));
       t+=0.1;
       cout<<fabs(VAL-V0[i+1])<<" "<<fabs(VAL-V1[i])<<"\n";
     }
  }
  FreeModel();
  cout<<endl;
  //for (int _N = 1; _N<8; _N++) {
  //    StartModel();
  //    RegisterVariable("_N",1.0*_N);
  //    RegisterVariable("_K",1.0*(_N%3));
  //    RegisterVariable("_M",1.0+(1<<_N%3));
  //    MarkModelPoint("Entry", true);
  //    double K=1.0;
  //    for (int j=1; j<_N; j++) {
  //        for (int i=0; i<(_N%3)*3000; i++)
  //            K += cos(0.99*i);
  //        MarkModelPoint("LOOP",true);
  //        for (int k=1/*j*/; k<1+(1<<_N%3); k++) { // !!!!!!!!!!!!!!!!!!!!!!! ОШИБКА ПРАВИЛА ПЕРЕХОДА!!!
  //            MarkModelPoint("LOOP1");
  //            for (int i=0; i<(_N%3)*3000; i++) {
  //                K += cos(0.99*i);
  //            }
  //            MarkModelPoint("ENDLOOP1");
  //        }
  //        MarkModelPoint("ENDLOOP");
  //    }
  //    MarkModelPoint("Exit", true);
  //    cout<<_N<<":"<<(K>=-100000?"":"Ух ты!!!")<<(Timings[_N-1]=pm::ModelTime)<<endl;
  //}
  for (int _N = 1; _N<6; _N++) {
      StartModel();
      RegisterVariable("_N",1.0*_N);
      MarkModelPoint("Entry", true);
      int k=0;
      double K=1.0;
      for (int j=1; j<_N; j++) {
          MarkModelPoint("LOOP2");
          for (int p=1; p<_N; p++) {
              MarkModelPoint("LOOP1");
              //RegisterVariable("p",p,true);
              //RegisterVariable("X0",0.17*10000*p*p*p*p,true);
              //RegisterVariable("X1",-0.1*10000*p*p*p,true);
              //RegisterVariable("X2",0.05*10000*p*p,true);
              //RegisterVariable("X3",-0.001*10000*p,true);
              //RegisterVariable("pp",(0.17*p*p*p*p-0.1*p*p*p+0.05*p*p-0.001*p)*10000,true);
                 for (int s=1; s<_N; s++) {
                   for (int i=0; i<(0.17*p*p*p*p-0.1*p*p*p+0.05*p*p-0.001*p)*10000; i++)
                       K += cos(0.99*i);
                  MarkModelPoint("LOOP",true);
                 }
              MarkModelPoint("ELOOP1");
          }
          MarkModelPoint("ELOOP2");
      }
      MarkModelPoint("ENDLOOP1",true);
      cout<<_N<<":"<<(K>=-100000?"":"Мдаааааа!!!")<<(Timings[_N-1]=pm::ModelTime)<<endl;
  }
  StopModel();
  ExportModelToCPP("States","States.cpp");
  if (ExportModelToLibrary("States","States.cpp",path,2,ipaths,2,lpaths)) {
     LastModel MMODEL = (LastModel) ImportModel("States","States.dll");
     for (int _N = 1; _N<6; _N++) {
         double NNN = _N;
         double TTTT = MMODEL(0.1,1000.0,NNN);
         cout<<_N<<" - predict = "<<TTTT<<" eps = "<<fabs(Timings[_N-1]-TTTT)<<" : "<<fabs(Timings[_N-1]-TTTT)/Timings[_N-1]<<endl;
     }
  }
  FreeModel();

  // Интерполяция через CUDA путем обучения, не прямого программирования
  // Компьютеры будущего -- группы подсказывающих и решающих обучаемых блоков
  // с координацией.
  
  // Предикция. Схемы с ментальной точкой (копирование алгоритмов). Время исполнения
  // для распараллеливания.

  return 0;
}