655 lines
No EOL
24 KiB
Text
655 lines
No EOL
24 KiB
Text
//+------------------------------------------------------------------+
|
|
//| ArrayPrinter.mq4 |
|
|
//| Copyright 2020, MetaQuotes Software Corp. |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Yevheniy Kopanitskyy"
|
|
#property link ""
|
|
#property version "1.00"
|
|
#property strict
|
|
double BodyHorizont_Bin[7210,2000];
|
|
double BodyHorizont_Price[7210,2000];
|
|
datetime BodyHorizont_Time[7210];
|
|
double MBodyHorizont_Bin[36050,2000];
|
|
double MBodyHorizont_Price[36050,2000];
|
|
datetime MBodyHorizont_Time[36050];
|
|
double PArticles_Bin[36050,500];
|
|
double PArticles_BinTemp[36050,500];
|
|
double PArticles_Price[36050,500];
|
|
double PArticles_PriceTemp[36050,500];
|
|
datetime PArticles_Time[36050,2];
|
|
string SYmbol=Symbol();
|
|
string FileName21=SYmbol+"BodyHorizont_Bin.bin";
|
|
string FileName22=SYmbol+"BodyHorizont_Price.bin";
|
|
string FileName23=SYmbol+"BodyHorizont_Time.bin";
|
|
string FileName24=SYmbol+"МBodyHorizont_Bin.bin";
|
|
string FileName25=SYmbol+"МBodyHorizont_Price.bin";
|
|
string FileName26=SYmbol+"МBodyHorizont_Time.bin";
|
|
string FileName27=SYmbol+"PArticles_Bin.bin";
|
|
string FileName28=SYmbol+"PArticles_Price.bin";
|
|
string FileName29=SYmbol+"PArticles_Time.bin";
|
|
extern bool automaticprinte=false;
|
|
extern bool AddToMBody=false;
|
|
extern bool Particles=true;
|
|
extern bool chek=false;
|
|
extern bool chek1=false;
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
//---
|
|
ArrayInitialize(MBodyHorizont_Bin,10);
|
|
ArrayInitialize(MBodyHorizont_Price,10);
|
|
ArrayInitialize(MBodyHorizont_Time,10);
|
|
ArrayInitialize(PArticles_Bin,10);
|
|
ArrayInitialize(PArticles_Price,10);
|
|
ArrayInitialize(PArticles_Time,10);
|
|
ArrayInitialize(PArticles_BinTemp,10);
|
|
//Загрузка массива при запуске
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
int file_handle17=FileOpen(FileName21,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle17>0)
|
|
{
|
|
|
|
FileSeek(file_handle17,0,SEEK_CUR);
|
|
|
|
uint test=FileReadArray(file_handle17,BodyHorizont_Bin,0,WHOLE_ARRAY);
|
|
FileClose(file_handle17);
|
|
}
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
int file_handle18=FileOpen(FileName22,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle18>0)
|
|
{
|
|
|
|
FileSeek(file_handle18,0,SEEK_CUR);
|
|
|
|
uint test=FileReadArray(file_handle18,BodyHorizont_Price,0,WHOLE_ARRAY);
|
|
FileClose(file_handle18);
|
|
}
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
int file_handle19=FileOpen(FileName23,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle19>0)
|
|
{
|
|
|
|
FileSeek(file_handle19,0,SEEK_CUR);
|
|
|
|
uint test=FileReadArray(file_handle19,BodyHorizont_Time,0,WHOLE_ARRAY);
|
|
FileClose(file_handle19);
|
|
}
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
int file_handle20=FileOpen(FileName24,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle20>0)
|
|
{
|
|
|
|
FileSeek(file_handle20,0,SEEK_CUR);
|
|
|
|
uint test=FileReadArray(file_handle20,MBodyHorizont_Bin,0,WHOLE_ARRAY);
|
|
FileClose(file_handle20);
|
|
}
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
int file_handle21=FileOpen(FileName25,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle21>0)
|
|
{
|
|
|
|
FileSeek(file_handle21,0,SEEK_CUR);
|
|
|
|
uint test=FileReadArray(file_handle21,MBodyHorizont_Price,0,WHOLE_ARRAY);
|
|
FileClose(file_handle21);
|
|
}
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
int file_handle22=FileOpen(FileName26,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle22>0)
|
|
{
|
|
|
|
FileSeek(file_handle22,0,SEEK_CUR);
|
|
|
|
uint test=FileReadArray(file_handle22,MBodyHorizont_Time,0,WHOLE_ARRAY);
|
|
FileClose(file_handle22);
|
|
}
|
|
//---
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
int file_handle23=FileOpen(FileName27,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle23>0)
|
|
{
|
|
|
|
FileSeek(file_handle23,0,SEEK_CUR);
|
|
|
|
uint test=FileReadArray(file_handle23,PArticles_Bin,0,WHOLE_ARRAY);
|
|
FileClose(file_handle23);
|
|
}
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
int file_handle24=FileOpen(FileName28,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle24>0)
|
|
{
|
|
|
|
FileSeek(file_handle24,0,SEEK_CUR);
|
|
|
|
uint test=FileReadArray(file_handle24,PArticles_Price,0,WHOLE_ARRAY);
|
|
FileClose(file_handle24);
|
|
}
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
int file_handle25=FileOpen(FileName29,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle25>0)
|
|
{
|
|
|
|
FileSeek(file_handle25,0,SEEK_CUR);
|
|
|
|
uint test=FileReadArray(file_handle25,PArticles_Time,0,WHOLE_ARRAY);
|
|
FileClose(file_handle25);
|
|
}
|
|
//Print("Ar test ",MBodyHorizont_Bin[152,20]);
|
|
//---Печать массивов в фаил
|
|
//-Определить с какой ячейки заполняется массив BodyHorizont_Bin с 0 или 1
|
|
if(automaticprinte==true)
|
|
{
|
|
for(int in=1; in<7210; in++)//Печатаю все данные в фаил по строкам
|
|
{
|
|
Sleep(500);
|
|
int ina;
|
|
for(ina=1; ina<2000; ina++) //Определяю конец строки
|
|
{
|
|
if(BodyHorizont_Bin[in,ina]==10)
|
|
{
|
|
|
|
break;//Конец строки
|
|
|
|
}
|
|
|
|
}
|
|
int inb;
|
|
//Print(ina);
|
|
Print(BodyHorizont_Time[in]);
|
|
for(inb=1; inb<ina; inb++)
|
|
{
|
|
Print("Bin Secuency ",BodyHorizont_Bin[in,inb]);
|
|
}
|
|
for(inb=1; inb<ina; inb++)
|
|
{
|
|
Print("Price Secuency ",BodyHorizont_Price[in,inb]);
|
|
}
|
|
|
|
}
|
|
}
|
|
if(automaticprinte==false)
|
|
{
|
|
int in=1;//Номер строки в массиве
|
|
int ina;
|
|
int inb;
|
|
for(ina=1; ina<2000; ina++) //Определяю конец строки
|
|
{
|
|
if(BodyHorizont_Bin[in,ina]==10)
|
|
{
|
|
|
|
break;//Конец строки
|
|
|
|
}
|
|
|
|
}
|
|
Print(ina);
|
|
Print(BodyHorizont_Time[in]);
|
|
for(inb=1; inb<ina; inb++)
|
|
{
|
|
Print("Bin Secuency ",BodyHorizont_Bin[in,inb]);
|
|
}
|
|
for(inb=1; inb<ina; inb++)
|
|
{
|
|
Print("Price Secuency ",BodyHorizont_Price[in,inb]);
|
|
}
|
|
|
|
}
|
|
//Выбрать глубину массива для дозаписи и вывести на экран
|
|
int inc;
|
|
for(inc=1; inc<36050; inc++)
|
|
{
|
|
if(MBodyHorizont_Bin[inc,1]==10)//Индекс заполненности месячного массива
|
|
{
|
|
Print("START ADD MBODY INDEX - Max 36050 ",inc);
|
|
break;
|
|
}
|
|
}
|
|
|
|
int ind;
|
|
for(ind=1; ind<7210; ind++)
|
|
{
|
|
if(BodyHorizont_Bin[ind,1]==10)//Индекс загружаемого массива для обьеденения
|
|
{
|
|
Print(" Start ADD BODY INDEX - Max 7210 ",ind);
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
int ControlInc=inc;
|
|
|
|
if(BodyHorizont_Bin[7209,1]!=10)
|
|
{
|
|
ind=7210;
|
|
Print(" Array BodyHorizont_Bin Full Loaded");
|
|
|
|
}
|
|
//int swi=0;
|
|
//if(inc-ind<=0)//Правило. Если колличество записываемых элементов меньше 0 то не писать в массив а вывести на печать оповещение
|
|
// {
|
|
// Print(" Small Array Manth SIZE FOR ADD NEW DATA ",inc-ind);
|
|
// swi=1;
|
|
// }
|
|
if(AddToMBody==true)
|
|
{
|
|
//Определение Конца текущего массива
|
|
//Дозагруска данных в массивы
|
|
|
|
int ini;
|
|
int inf=0;
|
|
|
|
|
|
for(ini=inc; ini<ind; ini++)//inc индекс старта записи в массив месяца. inc+ind Индекс массива месяц + колличество элементов к заполнению
|
|
{
|
|
|
|
inf++;//Увеличиваю строку массива для перезаписи
|
|
//Print(" ini ",ini," inf ",inf);
|
|
int ine;
|
|
for(ine=1; ine<2000; ine++) //дозапись собранных элементов в месячный массив
|
|
{
|
|
MBodyHorizont_Bin[ini,ine]=BodyHorizont_Bin[inf,ine];
|
|
MBodyHorizont_Price[ini,ine]=BodyHorizont_Price[inf,ine];
|
|
MBodyHorizont_Time[ini]=BodyHorizont_Time[inf];
|
|
}
|
|
|
|
}
|
|
|
|
for(inc=1; inc<36050; inc++)
|
|
{
|
|
if(MBodyHorizont_Bin[inc,1]==10)//Индекс заполненности месячного массива
|
|
{
|
|
Print("END ADD MBODY INDEX - Max 36050 ",inc);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(inc>ControlInc)
|
|
{
|
|
FileDelete(SYmbol+"BodyHorizont_Bin.bin",0);
|
|
FileDelete(SYmbol+"BodyHorizont_Price.bin",0);
|
|
FileDelete(SYmbol+"BodyHorizont_Time.bin",0);
|
|
Print(" Files BodyHorizont_XXX Delited");
|
|
}
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
file_handle20=FileOpen(FileName24,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle20>0)
|
|
{
|
|
|
|
FileSeek(file_handle20,0,SEEK_CUR);
|
|
|
|
uint test=FileWriteArray(file_handle20,MBodyHorizont_Bin,0,WHOLE_ARRAY);
|
|
FileClose(file_handle20);
|
|
}
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
file_handle21=FileOpen(FileName25,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle21>0)
|
|
{
|
|
|
|
FileSeek(file_handle21,0,SEEK_CUR);
|
|
|
|
uint test=FileWriteArray(file_handle21,MBodyHorizont_Price,0,WHOLE_ARRAY);
|
|
FileClose(file_handle21);
|
|
}
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
file_handle22=FileOpen(FileName26,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle22>0)
|
|
{
|
|
|
|
FileSeek(file_handle22,0,SEEK_CUR);
|
|
|
|
uint test=FileWriteArray(file_handle22,MBodyHorizont_Time,0,WHOLE_ARRAY);
|
|
FileClose(file_handle22);
|
|
}
|
|
//---
|
|
|
|
}
|
|
|
|
if(Particles==true)
|
|
{
|
|
//Разбор собранных данных на частицы.Точка разделения Бинарный синапс. где синапс цены выражается 01 при тойже цене.
|
|
//Класификация и отбор дублей в отдельный массив.
|
|
//Перебераем массив и определяем координаты синапса.Есть два варианта. Последовательный перебор или перебор с предварительным выделением синапсов с записью в массив
|
|
//Последавательный варриант.
|
|
//загрузка базы данных в массив для проведения анализа
|
|
//загрузка базы данных отсортированных элементов. Нужно знать время свечи с которой была взята частица.Максимальная длинна частицы 200 элементов
|
|
//Цикл определения синапса
|
|
int ing;
|
|
int inh;
|
|
//Проверяю заполненность массива
|
|
for(ing=1; ing<36050; ing++)
|
|
{
|
|
if(MBodyHorizont_Bin[ing,1]==10)
|
|
{
|
|
break;//inh содержит индекс конца массива
|
|
}
|
|
|
|
}
|
|
|
|
int inl;
|
|
int inm=1;//строка для записи
|
|
int inn=-1;//ячейка в записи
|
|
for(inh=1; inh<ing; inh++) //Перебираю построчно Массив хранящий собранные данные MBodyHorizont_Bin массив содержит данные одного месяца
|
|
{
|
|
//перебераю строку в поиске синапса.Пришла идея слаживать все синапсы во временный массив а после сортиравать на дубли
|
|
int ink;
|
|
for(ink=1; ink<2000; ink++)
|
|
{
|
|
if(MBodyHorizont_Bin[inh,ink]==10)//Конец строки
|
|
{
|
|
|
|
break;//ink содержит конец строки
|
|
}
|
|
}
|
|
|
|
bool permwr;//переключатель для разешения записи в массив
|
|
for(inl=1; inl<ink; inl++)//перебор подаваемой строки
|
|
{
|
|
//Print("TEST ",inl);
|
|
permwr=true;
|
|
inn++;//увеличиваю число ячейки для записи
|
|
if(inn==500)
|
|
{
|
|
|
|
Print("inn 500 true");
|
|
}
|
|
if(MBodyHorizont_Bin[inh,inl]==0 && MBodyHorizont_Bin[inh,inl+1]==1 && MBodyHorizont_Price[inh,inl]==MBodyHorizont_Price[inh,inl+1])//Условие по которому определяется синапс
|
|
{
|
|
//Print(" 0 ",MBodyHorizont_Bin[inh,inl]);
|
|
//Print(" 1 ",MBodyHorizont_Bin[inh,inl+1]);
|
|
//Print(" Price1 ",MBodyHorizont_Price[inh,inl]);
|
|
//Print(" Price2 ",MBodyHorizont_Price[inh,inl+1]);
|
|
//Print(" coordenada de sinaps " ," Line ",inh," Bin Position ",inl+1);//Печатаю координату в массиве где определён синапс
|
|
//Print(" Coordenada de tiempo " ,MBodyHorizont_Time[inh]);//Печатаю время в массиве где определён синапс
|
|
PArticles_BinTemp[inm,inn]=MBodyHorizont_Bin[inh,inl];//Записываю 0 по индексу inl
|
|
PArticles_PriceTemp[inm,inn]=MBodyHorizont_Price[inh,inl];//Записываю цену по индексу inl
|
|
permwr=false;
|
|
inm++;// устанавливаю номер строки +1
|
|
inn=0;// устанавливаю номер ячейки на 0
|
|
//Print("sw");
|
|
//inl=inl+1;
|
|
if(inm==99999)
|
|
{
|
|
Print("file PArticles_BinTemp.bin is ful");
|
|
Alert("file PArticles_BinTemp.bin is ful");
|
|
break;//Выход из цикла по заполненности массива
|
|
}
|
|
|
|
}
|
|
//Print("str1 ",inh," yach ",inl);
|
|
//Print("str2 ",inm," yach ",inn);
|
|
if(permwr==true)//Коррекция записи в массивы
|
|
{
|
|
PArticles_BinTemp[inm,inn]=MBodyHorizont_Bin[inh,inl];//присваиваю параметр бинарного кода
|
|
PArticles_PriceTemp[inm,inn]=MBodyHorizont_Price[inh,inl];//присваиваю параметр цены
|
|
}
|
|
//Print(PArticles_BinTemp[inm,inn]);
|
|
|
|
}
|
|
|
|
|
|
}
|
|
if(chek==true)
|
|
{
|
|
int ino;
|
|
int inp;
|
|
int inq;
|
|
int inr;
|
|
for(inq=1; inq<36050; inq++)
|
|
{
|
|
if(PArticles_BinTemp[inq,1]==10)
|
|
{
|
|
// Print("glubina massiva Proverka ",inq);
|
|
break;
|
|
}
|
|
|
|
}
|
|
for(ino=1; ino<inq; ino++)//перебор подаваемой строки
|
|
{
|
|
for(inr=1; inr<500; inr++)
|
|
{
|
|
if(PArticles_BinTemp[ino,inr]==10)
|
|
{
|
|
// Print("dlinnaa massiva Proverka ",inr);
|
|
break;
|
|
}
|
|
}
|
|
Print("inr ",inr);
|
|
for(inp=1; inp<inr; inp++)//перебор подаваемой ячейки
|
|
{
|
|
|
|
Print("stroka ",ino," Znacheni ",PArticles_BinTemp[ino,inp]);
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}//проверка
|
|
//-----------Сортировка собранных значений на дубли с использаванием цены и времени.Запись данных в фаил для вывидения на индикатор---------------
|
|
int ins;//Строка
|
|
int iny;//Ячейкa
|
|
int inv;//Проверка глубены
|
|
int inw;//Проверка длинны строки
|
|
int ias=0;//щётчик
|
|
int iad;
|
|
double temArr[500];
|
|
|
|
for(inv=1; inv<36050; inv++)
|
|
{
|
|
ArrayInitialize(temArr,10);
|
|
Print("Control array write PArticles_BinTemp[inv,0] ", PArticles_BinTemp[inv,0]," ",PArticles_BinTemp[inv,1]);
|
|
if(PArticles_BinTemp[inv,1]!=10)
|
|
{
|
|
for(ins=0; ins<500; ins++) //Заполняю временный массив
|
|
{
|
|
temArr[ins]=PArticles_BinTemp[inv,ins];//Присваиваю значения во временный массив для сравнения с основным массивом.
|
|
|
|
}
|
|
}
|
|
//Перебираю массив в посках дубля
|
|
for(iny=inv+1; iny<36050; ins++) // строка
|
|
{
|
|
ias=0;
|
|
for(inw=0; inw<500; inw++) //Ячейки
|
|
{
|
|
if(PArticles_BinTemp[iny,inw]==temArr[inw])//Если соответствуют элементы. Должен получить число 499
|
|
{
|
|
ias++;
|
|
|
|
}
|
|
}
|
|
//Если ias равен 499 то значения нужно удалить так как это дубль. Если не равен то пропустить
|
|
if(ias==499)
|
|
{
|
|
for(iad=0; iad<500; iad++) //Ячейки
|
|
{
|
|
PArticles_BinTemp[iny,ind]=10;//Заполняю массив числом 10
|
|
}
|
|
}
|
|
|
|
|
|
}//end
|
|
|
|
|
|
}//end
|
|
//--------------------------------------------------------
|
|
for(ins=1; ins<inv; ins++) //Перебераю строки в массиве
|
|
{
|
|
|
|
}
|
|
// int inaa;//длинна строки
|
|
// for(inaa=1; inaa<500; inaa++)
|
|
// {
|
|
// if(PArticles_BinTemp[ins,inaa]==10)
|
|
// {
|
|
// break;//Конец строки
|
|
// }
|
|
// }
|
|
|
|
//--------------Вариант отфильтровки массива PArticles_BinTemp на дубли с заполнением числом 10 строки дубля-----------------------------------------
|
|
|
|
|
|
//-------------------------------------------------------
|
|
// if(inw==inaa)//Если колличество элементов 2 строк равны то сравнивать на не соответствие и записыать если нет соответствия
|
|
// {
|
|
// for(iny=1; iny<inw; iny++)
|
|
// {
|
|
|
|
// if(PArticles_BinTemp[ins,iny]!=PArticles_Bin[ins,iny])//нужно найти дубли в исходном массиве//есть два типа филтрации по бинарному коду и с использаванием цены
|
|
// {
|
|
// если нет соответсвия в базе значит дописать
|
|
// int inx;//Строка
|
|
// int inz;//Ячейкa
|
|
// for(inx=1; inx<36050; inx++)
|
|
// {
|
|
// if(PArticles_Bin[inx,1]==10)
|
|
// {
|
|
// break;//глубина заполненности
|
|
// }
|
|
// }
|
|
|
|
// for(inz=0; inz<500; inz++)//дозаписываю элемент
|
|
// {
|
|
// PArticles_Bin[inx,inz]=PArticles_BinTemp[ins,inz];//дописал не существующий элемен в массиве
|
|
// PArticles_Price[inx,inz]=PArticles_PriceTemp[ins,inz];//дописал не существующий элемен в массиве
|
|
// }
|
|
// for(inz=0; inz<500; inz++)//удаляю элементы числом 10
|
|
// {
|
|
// PArticles_BinTemp[ins,inz]=10;//дописал не существующий элемен в массиве
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
|
|
//По завершению отбора на не соответствие в строке и одинаковом колличестве елементов в массиве остатки дозаписать
|
|
//int inab;//строка
|
|
//int inac;//ячейка
|
|
//int inad;//ячейка
|
|
//for(inab=1; inab<36050; inab++)//удаляю элементы числом 10
|
|
// {
|
|
// if(PArticles_BinTemp[inab,1]!=10)//Если не заполнена 10 ячейка в массиве то пишем
|
|
// {
|
|
// for(inac=1; inac<36050; inac++)//удаляю элементы числом 10
|
|
// {
|
|
// if(PArticles_Bin[inac,1]==10)
|
|
// {
|
|
// break;
|
|
// }
|
|
// }
|
|
|
|
// if(inac==36049)
|
|
// {
|
|
// Print(" PArticles_Bin LOADED FULL");
|
|
// Alert(" PArticles_Bin LOADED FULL");
|
|
// break;
|
|
// }
|
|
//for(inad=0; inad<500; inad++)//удаляю элементы числом 10
|
|
// {
|
|
// PArticles_Bin[inac,inad]=PArticles_BinTemp[inab,inad];
|
|
// PArticles_Price[inac,inad]=PArticles_PriceTemp[inab,inad];
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
// }
|
|
//запись данных в фаил
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
file_handle23=FileOpen(FileName27,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle23>0)
|
|
{
|
|
|
|
FileSeek(file_handle23,0,SEEK_CUR);
|
|
|
|
uint test=FileWriteArray(file_handle23,PArticles_Bin,0,WHOLE_ARRAY);
|
|
FileClose(file_handle23);
|
|
}
|
|
file_handle24=FileOpen(FileName28,FILE_READ|FILE_WRITE|FILE_BIN);//Загрузка
|
|
if(file_handle24>0)
|
|
{
|
|
|
|
FileSeek(file_handle24,0,SEEK_CUR);
|
|
|
|
uint test=FileWriteArray(file_handle24,PArticles_Price,0,WHOLE_ARRAY);
|
|
FileClose(file_handle24);
|
|
}
|
|
//---
|
|
}//end
|
|
|
|
//Проверка заполненности и запись в фаил,последний этап отслеживания появление элемента в нутри рынка
|
|
if(chek1==true)
|
|
{
|
|
int ino;
|
|
int inp;
|
|
int inq;
|
|
int inr;
|
|
for(inq=1; inq<36050; inq++)
|
|
{
|
|
if(PArticles_Bin[inq,1]==10)
|
|
{
|
|
Print("glubina massiva BEZ DUBLEI ",inq);
|
|
break;
|
|
}
|
|
|
|
}
|
|
for(ino=1; ino<inq; ino++)//перебор подаваемой строки
|
|
{
|
|
for(inr=1; inr<500; inr++)
|
|
{
|
|
if(PArticles_Bin[ino,inr]==10)
|
|
{
|
|
// Print("dlinnaa massiva Proverka ",inr);
|
|
break;
|
|
}
|
|
}
|
|
Print("inr ",inr);
|
|
for(inp=1; inp<inr; inp++)//перебор подаваемой ячейки
|
|
{
|
|
|
|
Print("stroka ",ino," Znacheni ",PArticles_Bin[ino,inp]);
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}//проверка
|
|
//---
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
//---
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Expert tick function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick()
|
|
{
|
|
//---Обьеденение в годовой массив
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
|
|
|
|
//+------------------------------------------------------------------+ |