public string Renko_5_min_850(decimal[] Chislo_out, int i, int Regim_Rabota, int sistem_vector, int Stavka, Parametrs Parametr) // метод по заданию параметров классической системы
{
Class_Consructor_Transactiy QUIK = new Class_Consructor_Transactiy();
Plan_Volume_Position = Stavka;
// int Regim_Rabota - режим работы торгового робота 1 - заявки в API выставляются
// алгоритм циклической обработки котировок
if (Vector_Position == Cash) // если торговая позиция "в кеше" торгда проверяем исполнение стопов на вход в позицию
{
// если мы в кеше, то это значит что стопов на выход стоять не должно
// должны стоять стопы только на вход
if (Chislo_out[4] >= Stop_Bay_2) // идет проверка на пересечение стоп цены на вход в лонги
// если максимум свечи пересек цену стопа
{
Vector_Position = Bay; // направлеи позиции ставим на лонг
Volume_Position = Plan_Volume_Position; // размер позиции устанавливаем на размер плановой открытой позиции
Open_Position = Stop_Bay_2; //устанавливаем цену открытия позиции
Stop_Sell_1 = Open_Position - (H_Stop * Visota_Kanala); // устанавливаем стоп заявку на выход в Кешь из лонгов
Stop_Sell_2 = Open_Position - ((H_Stop + Filter_Stop) * Visota_Kanala); // устанавливае стоп заявку на вход в Шорты
Sum_Sdelok++; // если мы сменили позицию, значит произошла сделка
Stop_Bay_1 = 0; // сбрасываем он нам не нужен
Stop_Bay_2 = 0; // сбрасываем он нам не нужен
if (Regim_Rabota == 1 & sistem_vector == 1 & Plan_Volume_Position != 0) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(28, 2, 0, 0, Parametr); // Stop_Sell_2
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(29, 2, 0, 0, Parametr); // Stop_Bay_2
// теперь выставляем нужные
QUIK.Consructor_Transactiy(9, 1, Stop_Sell_1, Plan_Volume_Position, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(9, 2, Stop_Sell_2, Plan_Volume_Position, Parametr); // Stop_Sell_2
}
}
else
{
if (Chislo_out[5] <= Stop_Sell_2) // идет проверка на пересечение стоп цены на вход в шорт
// если минимум свечи пересек цену стопа
{
Vector_Position = Sell; // направлеи позиции ставим на лонг
Volume_Position = Plan_Volume_Position; // размер позиции устанавливаем на размер плановой открытой позиции
Open_Position = Stop_Sell_2; //устанавливаем цену открытия позиции на уровне стопа
Stop_Bay_1 = Open_Position + (H_Stop * Visota_Kanala); // устанавливаем стоп заявку на выход в Кешь из Шортов
Stop_Bay_2 = Open_Position + ((H_Stop + Filter_Stop) * Visota_Kanala); // устанавливае стоп заявку на вход в Лонги
Sum_Sdelok++; // если мы сменили позицию, значит произошла сделка
Stop_Sell_1 = 0; // сбрасываем он нам не нужен
Stop_Sell_2 = 0; // сбрасываем он нам не нужен
if (Regim_Rabota == 1 & sistem_vector == 1 & Plan_Volume_Position != 0) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(28, 2, 0, 0, Parametr); // Stop_Sell_2
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(29, 2, 0, 0, Parametr); // Stop_Bay_2
// теперь выставляем нужные
QUIK.Consructor_Transactiy(10, 1, Stop_Bay_1, Plan_Volume_Position, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(10, 2, Stop_Bay_2, Plan_Volume_Position, Parametr); // Stop_Bay_2
}
}
}
}
// -------------------- закончили проверку находясь в кеше ------------------ //
else // начали проверку стопов находясь в позиции
{
if (Vector_Position == Bay) // если мы находимся в покупке
{
if (Chislo_out[5] <= Stop_Sell_1) // идет проверка на пересечение стоп цены на выход в кешь
// если минимум свечи пересек цену стопа
{
Vector_Position = Cash; // направлеи позиции ставим на Cash
Volume_Position = 0; // размер позиции устанавливаем на размер плановой открытой позиции
Close_Position = Stop_Sell_1; //устанавливаем цену закрытия позиции
Stop_Sell_2 = Close_Position - (Filter_Stop * Visota_Kanala); // Корректируем стоп заявку на вход в шорт
Stop_Bay_2 = Close_Position + (H_Stop * Visota_Kanala); // Устанавливаем стоп заявку на обратный вход в лонг
Sum_Sdelok++; // если мы сменили позицию, значит произошла сделка
Rezultat_Sdelki = (Close_Position - Open_Position) - Parametr.Proskalzivania;
Stop_Sell_1 = 0; // сбрасываем он нам не нужен
Stop_Bay_1 = 0; // сбрасываем он нам не нужен
Open_Position = 0; // сбрасываем он нам не нужен
if (Regim_Rabota == 1 & sistem_vector == 1 & Plan_Volume_Position != 0) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(28, 2, 0, 0, Parametr); // Stop_Sell_2
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(29, 2, 0, 0, Parametr); // Stop_Bay_2
// теперь выставляем нужные
QUIK.Consructor_Transactiy(9, 2, Stop_Sell_2, Plan_Volume_Position, Parametr); // Stop_Sell_2
QUIK.Consructor_Transactiy(10, 2, Stop_Bay_2, Plan_Volume_Position, Parametr); // Stop_Bay_2
}
//-----закончили проверку на пересечения стопа первого уровня---//
if (Chislo_out[5] <= Stop_Sell_2) // идет проверка на пересечение стоп цены на вход в шорт
// если минимум свечи пересек цену стопа
{
Vector_Position = Sell; // направлеи позиции ставим на Шорт
Volume_Position = Plan_Volume_Position; // размер позиции устанавливаем на размер плановой открытой позиции
Open_Position = Stop_Sell_2; //устанавливаем цену открытия позиции
Stop_Bay_1 = Open_Position + (H_Stop * Visota_Kanala); // Устанавливаем уровень стопа на выход в кешь из шортов
Stop_Bay_2 = Stop_Bay_1 + (Filter_Stop * Visota_Kanala); // Устанавливаем уровень стопа на выход в лонг из кеша
Sum_Sdelok++; // если мы сменили позицию, значит произошла сделка
Stop_Sell_1 = 0; // сбрасываем он нам не нужен
Stop_Sell_2 = 0; // сбрасываем он нам не нужен
if (Regim_Rabota == 1 & sistem_vector == 1 & Plan_Volume_Position != 0) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(28, 2, 0, 0, Parametr); // Stop_Sell_2
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(29, 2, 0, 0, Parametr); // Stop_Bay_2
// теперь выставляем нужные
QUIK.Consructor_Transactiy(10, 1, Stop_Bay_1, Plan_Volume_Position, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(10, 2, Stop_Bay_2, Plan_Volume_Position, Parametr); // Stop_Bay_2
}
//-----закончили проверку на пересечения стопа второго уровня---//
}
}
else // если стоп заявка на выход в кешь не была пересечена,
// проводим проверку на достижение новых уровней.
{
if ((((Chislo_out[8] - Stop_Sell_1) - (H_Stop * Visota_Kanala)) / Visota_Kanala) >= 1 & Chislo_out[7] == 1) // проверяем шаг цены в кубиках ценой закрытия
// если цена закрытия выросла на 1 кубик и более
{ // рассчитываем шаг цены и округляем до целого кубика
Shag_Cen = Math.Floor(((Chislo_out[8] - Stop_Sell_1) - (H_Stop * Visota_Kanala)) / Visota_Kanala);
Stop_Sell_1 = Stop_Sell_1 + (Shag_Cen * Visota_Kanala); // передвигаем стоп на выход в кешь из лонгов на шаг цены в кубиках
Stop_Sell_2 = Stop_Sell_1 - (Filter_Stop * Visota_Kanala); // передвигаем стоп на вход в шорт из кеша на шаг цены в кубиках
if (Regim_Rabota == 1 & sistem_vector == 1) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(28, 2, 0, 0, Parametr); // Stop_Sell_2
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(29, 2, 0, 0, Parametr); // Stop_Bay_2
// теперь выставляем нужные
QUIK.Consructor_Transactiy(9, 1, Stop_Sell_1, Plan_Volume_Position, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(9, 2, Stop_Sell_2, Plan_Volume_Position, Parametr); // Stop_Sell_2
}
}
//------------закрыли проверку на скачек цены в сторону открытой позиции-------------////
}// --------------- закрыли всю ценовую проверку на позицию в лонгах ----- //
}
else
{
if (Vector_Position == Sell) // если мы находимся в продажах
{
if (Chislo_out[4] >= Stop_Bay_1) // идет проверка на пересечение стоп цены на выход в кешь
// если максимум свечи пересек цену стопа
{
Vector_Position = Cash; // направлеи позиции ставим на Cash
Volume_Position = 0; // размер позиции устанавливаем на размер плановой открытой позиции
Close_Position = Stop_Bay_1; //устанавливаем цену закрытия позиции
Stop_Bay_2 = Close_Position + (Filter_Stop * Visota_Kanala); // корректируем стопа для входа в лонги
Stop_Sell_2 = Close_Position - (H_Stop * Visota_Kanala); // Устанавливаем уровень стопа на обратный вход в шорт из кеша
Sum_Sdelok++; // если мы сменили позицию, значит произошла сделка
Rezultat_Sdelki = (Open_Position - Close_Position) - Parametr.Proskalzivania; // результат сделки
Stop_Bay_1 = 0; // сбрасываем он нам не нужен
Stop_Sell_1 = 0; // сбрасываем он нам не нужен
Open_Position = 0; // сбрасываем он нам не нужен
if (Regim_Rabota == 1 & sistem_vector == 1 & Plan_Volume_Position != 0) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(28, 2, 0, 0, Parametr); // Stop_Sell_2
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(29, 2, 0, 0, Parametr); // Stop_Bay_2
// теперь выставляем нужные
QUIK.Consructor_Transactiy(9, 2, Stop_Sell_2, Plan_Volume_Position, Parametr); // Stop_Sell_2
QUIK.Consructor_Transactiy(10, 2, Stop_Bay_2, Plan_Volume_Position, Parametr); // Stop_Bay_2
}
//-----закончили проверку на пересечения стопа первого уровня---//
if (Chislo_out[4] >= Stop_Bay_2) // идет проверка на пересечение стоп цены на вход в лонг
// если максимум свечи пересек цену стопа
{
Vector_Position = Bay; // направлеи позиции ставим на Шорт
Volume_Position = Plan_Volume_Position; // размер позиции устанавливаем на размер плановой открытой позиции
Open_Position = Stop_Bay_2; //устанавливаем цену открытия позиции
Stop_Sell_1 = Open_Position - (H_Stop * Visota_Kanala); // Устанавливаем уровень стопа на выход в кешь из лонгов
Stop_Sell_2 = Stop_Sell_1 - (Filter_Stop * Visota_Kanala); // Устанавливаем уровень стопа на вход в шорт из кеша
Sum_Sdelok++; // если мы сменили позицию, значит произошла сделка
Stop_Bay_1 = 0; // сбрасываем он нам не нужен
Stop_Bay_2 = 0; // сбрасываем он нам не нужен
if (Regim_Rabota == 1 & sistem_vector == 1 & Plan_Volume_Position != 0) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(28, 2, 0, 0, Parametr); // Stop_Sell_2
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(29, 2, 0, 0, Parametr); // Stop_Bay_2
// теперь выставляем нужные
QUIK.Consructor_Transactiy(9, 1, Stop_Sell_1, Plan_Volume_Position, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(9, 2, Stop_Sell_2, Plan_Volume_Position, Parametr); // Stop_Sell_2
}
//-----закончили проверку на пересечения стопа второго уровня---//
}
}
else // если стоп заявка на выход в кешь не была пересечена,
// проводим проверку на достижение новых уровней.
{
if ((((Stop_Bay_1 - Chislo_out[8]) - (H_Stop * Visota_Kanala)) / Visota_Kanala) >= 1 & Chislo_out[7] == 1) // проверяем шаг цены в кубиках ценой закрытия
// если цена закрытия выросла на 1 кубик и более
{ // рассчитываем шаг цены и округляем до целого кубика
Shag_Cen = Math.Floor(((Stop_Bay_1 - Chislo_out[8]) - (H_Stop * Visota_Kanala)) / Visota_Kanala);
Stop_Bay_1 = Stop_Bay_1 - (Shag_Cen * Visota_Kanala); // передвигаем стоп на выход в кешь из шортов на шаг цены в кубиках
Stop_Bay_2 = Stop_Bay_1 + (Filter_Stop * Visota_Kanala); // передвигаем стоп на вход в лонг из кеша на шаг цены в кубиках
if (Regim_Rabota == 1 & sistem_vector == 1 & Plan_Volume_Position != 0) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(28, 2, 0, 0, Parametr); // Stop_Sell_2
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(29, 2, 0, 0, Parametr); // Stop_Bay_2
// теперь выставляем нужные
QUIK.Consructor_Transactiy(10, 1, Stop_Bay_1, Plan_Volume_Position, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(10, 2, Stop_Bay_2, Plan_Volume_Position, Parametr); // Stop_Bay_2
}
}
//------------закрыли проверку на скачек цены в сторону открытой позиции-------------////
}
// --------------- закрыли всю ценовую проверку на позицию в шортах ----- //
}
}
}
if (Regim_Rabota == 1 & stapt_stop == 0)
{
// теперь выставляем нужные
QUIK.Consructor_Transactiy(10, 1, Stop_Bay_1, Plan_Volume_Position, Parametr); // Stop_Bay_1
QUIK.Consructor_Transactiy(10, 2, Stop_Bay_2, Plan_Volume_Position, Parametr); // Stop_Bay_2
// теперь выставляем нужные
QUIK.Consructor_Transactiy(9, 1, Stop_Sell_1, Plan_Volume_Position, Parametr); // Stop_Sell_1
QUIK.Consructor_Transactiy(9, 2, Stop_Sell_2, Plan_Volume_Position, Parametr); // Stop_Sell_2
stapt_stop++;
}
//* вывод расчетов на экран *//
Close_Position = 0; // обнуляем за ненадобностью
Rezerv_Rezultat_Sdelki = Rezultat_Sdelki;
Rezultat_Sdelki = 0; // обнуляем результат сделки
return(str_x);
}
private decimal Filter_Min; // фильтруем волатильность на минимум
public int Raschet_Molekula_Volatiliti(decimal[,] Baza_Vol, int Index_Molecula_Volatiliti, int i, Parametrs Parametr) // метод по расчету молекулы волатильности
{
i = i + Parametr.sdvig_korrelacii;
// Массив формата 7 столбцов
// Baza_Molecula_V[х, 0] - столбец с дата
// Baza_Molecula_V[х, 1] - столбец с расстоянием
// Baza_Molecula_V[х, 2] - столбец с точкой Max цикла
// Baza_Molecula_V[х, 3] - столбец с точкой Min цикла
// Baza_Molecula_V[х, 4] - столбец с значением Max цикла
// Baza_Molecula_V[х, 5] - столбец с значением Min цикла
// Baza_Molecula_V[х, 7] - столбец с значением i
U2 = V_BP; // 3200
Filter = Parametr.Filter_Volatiliti;
u_i = 0;
u = Index_Molecula_Volatiliti;
u_y = 0;
Filter_Max = 0;
Filter_Min = 0;
if (Baza_Molecula_V[0, 0] != 0)
{
// **************************** считаем для НЕ пустого массива **********
if ((Baza_Molecula_V[(u), 4] > 0) & (Baza_Molecula_V[(u), 2] == 1))
{
// start ********считаем ПРОДОЛЖЕНИЕ MAX *******
u_i = Convert.ToInt32(Baza_Molecula_V[u, 3]); // преобразуем данные
u_i--; // смещаем данные на один цикл назад, т.к. база волатильности перезаписалась
Filter_Max = Baza_Molecula_V[(u), 4]; // устанавливаем фильтр на текущий размер волатильности в цикле
// фильтруем значения по 100 пунктов
while ((Baza_Vol[(u_i), 1] > (Filter_Max - Filter)) & (u_i < (U2 - 1))) // фильтруем на максимум
{
if (Filter_Max < Baza_Vol[(u_i), 1])
{
Filter_Max = Baza_Vol[(u_i), 1];
u_y = u_i; // присваиваем координаты локального максимума
}
u_i++;
}
if (Baza_Vol[(u_i), 1] <= (Filter_Max - Filter)) // присваиваем индекс завершенности
{
Baza_Molecula_V[u, 2] = 0;
u_y = u_i;
Baza_Molecula_V[u, 6] = u; // присваиваем номер экстремума
}
else
{
Baza_Molecula_V[u, 2] = 1;
u_i--;
u_y = u_i;
}
Baza_Molecula_V[(u - 1), 3] = Baza_Molecula_V[(u - 1), 3] - 1;
// записываем результат в молекулу волатильности
Baza_Molecula_V[u, 0] = Baza_Vol[(u_y), 0]; // присваиваем дату
Baza_Molecula_V[u, 1] = u_i - Baza_Molecula_V[(u - 1), 3]; // устанавливаем расстояние от предыдущей точки
Baza_Molecula_V[u, 3] = u_i; // устанавливаем координаты последней остановки в массиве
Baza_Molecula_V[u, 4] = Filter_Max; // записываем значение максимума
Baza_Molecula_V[u, 5] = 0;
Baza_Molecula_V[u, 7] = i;
// end ********считаем ПРОДОЛЖЕНИЕ MAX *******
}
if ((Baza_Molecula_V[(u), 5] > 0) & (Baza_Molecula_V[(u), 2] == 1))
{
// start ********считаем ПРОДОЛЖАЕМ MIN *******
u_i = Convert.ToInt32(Baza_Molecula_V[u, 3]); // преобразуем данные
u_i--; // смещаем данные на один цикл назад, т.к. база волатильности перезаписалась
Filter_Min = Baza_Molecula_V[(u), 5]; // устанавливаем фильтр на текущий размер волатильности в цикле
// фильтруем значения по 100 пунктов
while ((Baza_Vol[(u_i), 1] < (Filter_Min + Filter)) & (u_i < (U2 - 1))) // фильтруем на максимум
{
if (Filter_Min > Baza_Vol[(u_i), 1])
{
Filter_Min = Baza_Vol[(u_i), 1];
u_y = u_i; // присваиваем координаты локального максимума
}
u_i++;
}
if (Baza_Vol[(u_i), 1] >= (Filter_Min + Filter)) // присваиваем индекс завершенности
{
Baza_Molecula_V[u, 2] = 0;
u_y = u_i;
Baza_Molecula_V[u, 6] = u; // присваиваем номер экстремума
}
else
{
Baza_Molecula_V[u, 2] = 1;
u_i--;
u_y = u_i;
}
Baza_Molecula_V[(u - 1), 3] = Baza_Molecula_V[(u - 1), 3] - 1;
// записываем результат в молекулу волатильности
Baza_Molecula_V[u, 0] = Baza_Vol[(u_y), 0]; // присваиваем дату
Baza_Molecula_V[u, 1] = u_i - Baza_Molecula_V[(u - 1), 3]; // устанавливаем расстояние от предыдущей точки
Baza_Molecula_V[u, 3] = u_i; // устанавливаем координаты последней остановки в массиве
Baza_Molecula_V[u, 4] = 0; // записываем значение максимума
Baza_Molecula_V[u, 5] = Filter_Min;
Baza_Molecula_V[u, 7] = i;
// end ********считаем ПРОДОЛЖАЕМ MIN *******
}
if ((Baza_Molecula_V[(u), 5] > 0) & (Baza_Molecula_V[(u), 2] != 1))
{
// start ********считаем НОВЫЙ MAX *******
u_i = Convert.ToInt32(Baza_Molecula_V[u, 3]); // получаем указатель на последнюю точку остановки
u_i--; // смещаем значение на одну еденицу из-за перезаписи массива волатильности после нового цикла расчетов
Filter_Max = Baza_Vol[(u_i), 1]; // устанавливаем фильтр на текущий размер волатильности в цикле
while ((Baza_Vol[(u_i), 1] >= (Filter_Max - Filter)) & (u_i < (U2 - 1))) // фильтруем на минимум
{
if (Filter_Max < Baza_Vol[(u_i), 1])
{
Filter_Max = Baza_Vol[(u_i), 1];
u_y = u_i; // присваиваем координаты локального максимума
}
u_i++;
}
// записываем результат в молекулу волатильности
if (Baza_Vol[(u_i), 1] <= (Filter_Max - Filter)) // присваиваем индекс завершенности
{
Baza_Molecula_V[(u + 1), 2] = 0;
Baza_Molecula_V[(u + 1), 6] = (u + 1); // присваиваем номер экстремума
}
else
{
Baza_Molecula_V[(u + 1), 2] = 1;
u_i--;
u_y = u_i;
}
Baza_Molecula_V[(u), 3] = Baza_Molecula_V[(u), 3] - 1;
Baza_Molecula_V[(u + 1), 0] = Baza_Vol[(u_y), 0]; // присваиваем дату
Baza_Molecula_V[(u + 1), 1] = u_y - Baza_Molecula_V[u, 3]; // устанавливаем расстояние от предыдущей точки
Baza_Molecula_V[(u + 1), 3] = u_y; // устанавливаем координаты последней остановки в массиве
Baza_Molecula_V[(u + 1), 4] = Filter_Max;
Baza_Molecula_V[(u + 1), 5] = 0; // записываем значение минимума
Baza_Molecula_V[(u + 1), 7] = i;
u = u + 1; //возвращаем индекс генома
// edn ********считаем НОВЫЙ MAX *******
}
if ((Baza_Molecula_V[(u), 4] > 0) & (Baza_Molecula_V[(u), 2] != 1))
{
// start ********считаем НОВЫЙ MIN *******
u_i = Convert.ToInt32(Baza_Molecula_V[u, 3]); // получаем указатель на последнюю точку остановки
u_i--; // смещаем значение на одну еденицу из-за перезаписи массива волатильности после нового цикла расчетов
Filter_Min = Baza_Vol[(u_i), 1]; // устанавливаем фильтр на текущий размер волатильности в цикле
while ((Baza_Vol[(u_i), 1] <= (Filter_Min + Filter)) & (u_i < (U2 - 1))) // фильтруем на минимум
{
if (Filter_Min > Baza_Vol[(u_i), 1])
{
Filter_Min = Baza_Vol[(u_i), 1];
u_y = u_i; // присваиваем координаты локального максимума
}
u_i++;
}
// записываем результат в молекулу волатильности
if (Baza_Vol[(u_i), 1] >= (Filter_Min + Filter)) // присваиваем индекс завершенности
{
Baza_Molecula_V[(u + 1), 2] = 0;
Baza_Molecula_V[(u + 1), 6] = (u + 1); // присваиваем номер экстремума
}
else
{
Baza_Molecula_V[(u + 1), 2] = 1;
u_i--;
u_y = u_i;
}
Baza_Molecula_V[(u), 3] = Baza_Molecula_V[(u), 3] - 1;
Baza_Molecula_V[(u + 1), 0] = Baza_Vol[(u_y), 0]; // присваиваем дату
Baza_Molecula_V[(u + 1), 1] = u_y - Baza_Molecula_V[u, 3]; // устанавливаем расстояние от предыдущей точки
Baza_Molecula_V[(u + 1), 3] = u_y; // устанавливаем координаты последней остановки в массиве
Baza_Molecula_V[(u + 1), 4] = 0;
Baza_Molecula_V[(u + 1), 5] = Filter_Min; // записываем значение минимума
Baza_Molecula_V[(u + 1), 7] = i;
u = u + 1; //возвращаем индекс генома
// end ********считаем НОВЫЙ MIN *******
}
}
else // считаем для ПУСТОГО массива в обе стороны
{
// **************************** считаем для ПУСТОГО массива **********
u = 0;
if (Baza_Vol[0, 1] > Baza_Vol[50, 1]) // проверяем рост или падение волатильности
{
// если волатильность падает
// обращаемся к базе волатильности к дате следующей за детектированной датой
u_i = 0;
// фильтруем значения по 100 пунктов
Filter_Min = Baza_Vol[(u_i), 1]; // устанавливаем фильтр на текущий размер волатильности в цикле
while ((Baza_Vol[(u_i), 1] < (Filter_Min + Filter)) & (u_i < (U2 - 1))) // фильтруем на минимум
{
if (Filter_Min > Baza_Vol[(u_i), 1])
{
Filter_Min = Baza_Vol[(u_i), 1];
u_y = u_i; // присваиваем координаты локального максимума
if (Baza_Vol[(u_i), 1] < (Filter_Min + Filter)) // присваиваем индекс завершенности
{
Baza_Molecula_V[u, 2] = 0;
Baza_Molecula_V[(u), 6] = (u); // присваиваем номер экстремума
}
else
{
Baza_Molecula_V[u, 2] = 1;
}
}
u_i++;
}
// записываем результат в молекулу волатильности
Baza_Molecula_V[u, 0] = Baza_Vol[(u_y), 0]; // присваиваем дату
Baza_Molecula_V[u, 1] = u_y; // устанавливаем расстояние от предыдущей точки
Baza_Molecula_V[u, 3] = u_y; // устанавливаем координаты последней остановки в массиве
Baza_Molecula_V[u, 4] = 0;
Baza_Molecula_V[u, 5] = Filter_Min; // записываем значение минимума
Baza_Molecula_V[u, 7] = i;
}
else // пустая молекула, если волатильность растет
{
// обращаемся к базе волатильности к дате следующей за детектированной датой
u_i = 0;
// фильтруем значения по 100 пунктов
Filter_Max = Baza_Vol[(u_i), 1]; // устанавливаем фильтр на текущий размер волатильности в цикле
while ((Baza_Vol[(u_i), 1] > (Filter_Max - Filter)) & (u_i < (U2 - 1))) // фильтруем на максимум
{
if (Filter_Max < Baza_Vol[(u_i), 1])
{
Filter_Max = Baza_Vol[(u_i), 1]; // присваиваем значение локального максимума
u_y = u_i; // присваиваем координаты локального максимума
if (Baza_Vol[(u_i), 1] > (Filter_Max - Filter)) // присваиваем индекс завершенности
{
Baza_Molecula_V[u, 2] = 0;
Baza_Molecula_V[(u), 6] = (u); // присваиваем номер экстремума
}
else
{
Baza_Molecula_V[u, 2] = 1;
}
}
u_i++;
}
// записываем результат в молекулу волатильности
Baza_Molecula_V[u, 0] = Baza_Vol[(u_y), 0]; // присваиваем дату
Baza_Molecula_V[u, 1] = u_y; // устанавливаем расстояние от предыдущей точки
Baza_Molecula_V[u, 3] = u_y; // устанавливаем координаты последней остановки в массиве
Baza_Molecula_V[u, 4] = Filter_Max; // записываем значение максимума
Baza_Molecula_V[u, 5] = 0;
Baza_Molecula_V[u, 7] = i;
}
}
return(u);
}
public decimal[,] Baza_Vol = new decimal[V_BP, 3]; // создаем массив для хранения значений волатильности
public decimal[,] Raschet_Baza_Volatiliti(decimal[] Chislo_out, decimal Vol, int i, Parametrs Parametr) // метод по заполнению базы волатильности
{
// Baza_Vol (3200 строк) (2 столбца)
// 1-й столбец содержит дату дня последнего добавления цены закрытия
// 2-й столбец содержит расчетную волатильность в этот день
// 3-й столец содержит индекс i
u = 1;
U2 = V_BP;
while (u < (U2)) // сдвиг данных массива на 1 ячейку с удалением последней записи
{
Baza_Vol[(u - 1), 0] = Baza_Vol[(u), 0];
Baza_Vol[(u - 1), 1] = Baza_Vol[(u), 1];
Baza_Vol[(u - 1), 2] = Baza_Vol[(u), 2];
u++;
}
Baza_Vol[(V_BP - 1), 0] = Chislo_out[1]; // новую дату расчета волатильности загоняем в массив
Baza_Vol[(V_BP - 1), 1] = Vol; // новую расчетную волатильность загоняем в массив
Baza_Vol[(V_BP - 1), 2] = i; //
return(Baza_Vol);
}
public string str_x; // строка для вывода данных в файл
public decimal Raschet_Protiv_RENKO_5_850(decimal[] Chislo_out, decimal Stop_Sell_2, decimal Stop_Bay_2, decimal Visota_Kanala, decimal Vector_Renko, int i, int Regim_Rabota, int sistem_vector, Parametrs Parametr)
{
Delta_hMAX = Parametr.Delta_hMAX;
Delta_hMIN = Parametr.Delta_hMIN;
Cikl = Parametr.Cikl;
Plan_Volume_Position = C01.Stavka_xR01(Parametr);
Class_Consructor_Transactiy QUIK = new Class_Consructor_Transactiy();
// если изначально мы находились в кеше и всю торговлю начинаем заново, тогда
// расставляем стопы на вход в обратном порядке стопам трендовой системы
if (Vector_Position == Cash & in_Sell == 0 & in_Bay == 0)
{
in_Sell = Stop_Bay_2; // ЗАЯВКА на вход в продажи
in_Bay = Stop_Sell_2; // ЗАЯВКА на вход в покупки
}
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(19, 1, 0, 0, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay - точка выхода из продаж в Cash (убыточная)
QUIK.Consructor_Transactiy(20, 1, 0, 0, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
QUIK.Consructor_Transactiy(20, 2, 0, 0, Parametr); // in_Bay - точка входа в лонг
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell - точка выхода из покупок в Cash (убыточная)
QUIK.Consructor_Transactiy(19, 2, 0, 0, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(1, 1, in_Sell, Plan_Volume_Position, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(2, 2, in_Bay, Plan_Volume_Position, Parametr); // in_Bay - точка входа в лонг
}
//ценовые данные текущего этажа
// x.Chislo_out[0] - таймфрейм
// x.Chislo_out[1] - дата
// x.Chislo_out[2] - время
// x.Chislo_out[3] - open
// x.Chislo_out[4] - max
// x.Chislo_out[5] - min
// x.Chislo_out[6] - close
// если цена пересекает заявку на вход в SHORT
// входим в продажу
if (Vector_Position == Cash & Chislo_out[4] >= in_Sell & in_Bay == 0)
{
Vector_Position = Sell;
Volume_Position = Plan_Volume_Position;
Shag_Sell = in_Sell + Visota_Kanala;
Stop_Bay = Shag_Sell + (Visota_Kanala * Delta_hMAX); // увеличение
Buf_in_Sell = in_Sell; // середина
z_Bay = in_Sell - (Visota_Kanala * Delta_hMIN); // уменьшение
Buf_z_Bay = z_Bay;
in_Bay = z_Bay - Visota_Kanala;
Plan_Cikl++;
Sum_Sdelok++;
Open_Position = in_Sell;
Close_Position = 0;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(19, 1, 0, 0, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay - точка выхода из продаж в Cash (убыточная)
QUIK.Consructor_Transactiy(20, 1, 0, 0, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
QUIK.Consructor_Transactiy(20, 2, 0, 0, Parametr); // in_Bay - точка входа в лонг
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell - точка выхода из покупок в Cash (убыточная)
QUIK.Consructor_Transactiy(19, 2, 0, 0, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(10, 1, Stop_Bay, Plan_Volume_Position, Parametr); // Stop_Bay - точка выхода из продаж в Cash (убыточная)
QUIK.Consructor_Transactiy(2, 1, z_Bay, Plan_Volume_Position, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
QUIK.Consructor_Transactiy(2, 2, in_Bay, Plan_Volume_Position, Parametr); // in_Bay - точка входа в лонг
}
in_Sell = 0;
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
}
// если цена пересекает заявку на вход в LONG
// входим в покупки
if (Vector_Position == Cash & Chislo_out[5] <= in_Bay & in_Sell == 0)
{
Vector_Position = Bay;
Volume_Position = Plan_Volume_Position;
Shag_Bay = in_Bay - Visota_Kanala;
Stop_Sell = Shag_Bay - (Visota_Kanala * Delta_hMAX); // увеличение
Buf_in_Bay = in_Bay; // середина
z_Sell = in_Bay + (Visota_Kanala * Delta_hMIN); // уменьшение
Buf_z_Sell = z_Sell;
in_Sell = z_Sell + Visota_Kanala;
Plan_Cikl++;
Sum_Sdelok++;
Open_Position = in_Bay;
Close_Position = 0;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(19, 1, 0, 0, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay - точка выхода из продаж в Cash (убыточная)
QUIK.Consructor_Transactiy(20, 1, 0, 0, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
QUIK.Consructor_Transactiy(20, 2, 0, 0, Parametr); // in_Bay - точка входа в лонг
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell - точка выхода из покупок в Cash (убыточная)
QUIK.Consructor_Transactiy(19, 2, 0, 0, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(1, 1, in_Sell, Plan_Volume_Position, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(9, 1, Stop_Sell, Plan_Volume_Position, Parametr); // Stop_Sell - точка выхода из покупок в Cash (убыточная)
QUIK.Consructor_Transactiy(1, 2, z_Sell, Plan_Volume_Position, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
}
in_Bay = 0;
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
}
// если мы в CASH, но пересечения не произашло. но уровень стопов в ренков изменился
// тогда подтягиваем наши стопы
if (Vector_Position == Cash & in_Sell != 0)
{
in_Sell = Stop_Bay_2;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(19, 1, 0, 0, Parametr); // in_Sell - точка входа в шорт
// теперь выставляем нужные
QUIK.Consructor_Transactiy(1, 1, in_Sell, Plan_Volume_Position, Parametr); // in_Sell - точка входа в шорт
}
}
if (Vector_Position == Cash & in_Bay != 0)
{
in_Bay = Stop_Sell_2;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(20, 2, 0, 0, Parametr); // in_Bay - точка входа в лонг
// теперь выставляем нужные
QUIK.Consructor_Transactiy(2, 2, in_Bay, Plan_Volume_Position, Parametr); // in_Bay - точка входа в лонг
}
}
// если мы в SHORT
// цена опускается до уровня фиксации ПРИБЫЛИ zBay
if (Vector_Position == Sell & Chislo_out[5] <= z_Bay & Volume_Position == Plan_Volume_Position & Plan_Cikl != Cikl)
{
in_Sell = Buf_in_Sell; // середина
Buf_z_Bay = z_Bay;
z_Bay = 0; // уменьшение
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(19, 1, 0, 0, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(20, 1, 0, 0, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(1, 1, in_Sell, Plan_Volume_Position, Parametr); // in_Sell - точка входа в шорт
}
Volume_Position = 0;
Plan_Cikl++;
Sum_Sdelok++;
Close_Position = Buf_z_Bay;
Local_Profit = Local_Profit + (Open_Position - Close_Position);
Rezultat_Sdelki = (Open_Position - Close_Position) / Visota_Kanala;
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
}
// если мы в LONG
// цена поднимается до уровня фиксации ПРИБЫЛИ zSell
if (Vector_Position == Bay & Chislo_out[4] >= z_Sell & Volume_Position == Plan_Volume_Position & Plan_Cikl != Cikl)
{
in_Bay = Buf_in_Bay;
Buf_z_Sell = z_Sell;
z_Sell = 0;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(20, 2, 0, 0, Parametr); // in_Bay - точка входа в лонг
QUIK.Consructor_Transactiy(19, 2, 0, 0, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(2, 2, in_Bay, Plan_Volume_Position, Parametr); // in_Bay - точка входа в лонг
}
Volume_Position = 0;
Plan_Cikl++;
Sum_Sdelok++;
Close_Position = Buf_z_Sell;
Local_Profit = Local_Profit + (Close_Position - Open_Position);
Rezultat_Sdelki = (Close_Position - Open_Position) / Visota_Kanala;
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
}
// еслим мы в SHORT
// цена поднимается до уровня начального входа in_Sell
if (Vector_Position == Sell & Chislo_out[4] >= Buf_in_Sell & Volume_Position == 0 & Plan_Cikl != Cikl)
{
Buf_in_Sell = in_Sell;
z_Bay = Buf_z_Bay;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(19, 1, 0, 0, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(20, 1, 0, 0, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(2, 1, z_Bay, Plan_Volume_Position, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
}
Volume_Position = Plan_Volume_Position;
Sum_Sdelok++;
Open_Position = in_Sell;
Plan_Cikl++;
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
}
// если мы в LONG
// цена поднимается до уровня начального входа в in_Bay
if (Vector_Position == Bay & Chislo_out[5] <= Buf_in_Bay & Volume_Position == 0 & Plan_Cikl != Cikl)
{
Buf_in_Bay = in_Bay;
z_Sell = Buf_z_Sell;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(20, 2, 0, 0, Parametr); // in_Bay - точка входа в лонг
QUIK.Consructor_Transactiy(19, 2, 0, 0, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(1, 2, z_Sell, Plan_Volume_Position, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
}
Volume_Position = Plan_Volume_Position;
Plan_Cikl++;
Sum_Sdelok++;
Open_Position = in_Bay;
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
}
// если мы в SHORT
// цена опускается до уровня переворота в LONG
if (Vector_Position == Sell & Chislo_out[5] <= in_Bay)
{
Shag_Sell = 0;
Stop_Bay = 0; // увеличение
in_Sell = 0;
Buf_in_Sell = 0; // середина
z_Bay = 0; // уменьшение
Buf_z_Bay = 0;
Vector_Position = Bay;
Volume_Position = Plan_Volume_Position;
Shag_Bay = in_Bay - Visota_Kanala;
Stop_Sell = Shag_Bay - Visota_Kanala; // увеличение
Buf_in_Bay = in_Bay; // середина
z_Sell = in_Bay + Visota_Kanala; // уменьшение
Buf_z_Sell = z_Sell;
in_Sell = z_Sell + Visota_Kanala;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(19, 1, 0, 0, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay - точка выхода из продаж в Cash (убыточная)
QUIK.Consructor_Transactiy(20, 1, 0, 0, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
QUIK.Consructor_Transactiy(20, 2, 0, 0, Parametr); // in_Bay - точка входа в лонг
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell - точка выхода из покупок в Cash (убыточная)
QUIK.Consructor_Transactiy(19, 2, 0, 0, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(1, 1, in_Sell, Plan_Volume_Position, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(9, 1, Stop_Sell, Plan_Volume_Position, Parametr); // Stop_Sell - точка выхода из покупок в Cash (убыточная)
QUIK.Consructor_Transactiy(1, 2, z_Sell, Plan_Volume_Position, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
}
in_Bay = 0;
Sum_Sdelok++;
Open_Position = Buf_in_Bay;
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
}
// если мы в LONG
// цена поднимается до уровня переворота в SHORT
if (Vector_Position == Bay & Chislo_out[4] >= in_Sell)
{
Shag_Bay = 0;
Stop_Sell = 0; // увеличение
in_Bay = 0;
Buf_in_Bay = 0; // середина
z_Sell = 0; // уменьшение
Buf_z_Sell = 0;
Vector_Position = Sell;
Volume_Position = Plan_Volume_Position;
Shag_Sell = in_Sell + Visota_Kanala;
Stop_Bay = Shag_Sell + Visota_Kanala; // увеличение
Buf_in_Sell = in_Sell; // середина
z_Bay = in_Sell - Visota_Kanala; // уменьшение
Buf_z_Bay = z_Bay;
in_Bay = z_Bay - Visota_Kanala;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(19, 1, 0, 0, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay - точка выхода из продаж в Cash (убыточная)
QUIK.Consructor_Transactiy(20, 1, 0, 0, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
QUIK.Consructor_Transactiy(20, 2, 0, 0, Parametr); // in_Bay - точка входа в лонг
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell - точка выхода из покупок в Cash (убыточная)
QUIK.Consructor_Transactiy(19, 2, 0, 0, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(10, 1, Stop_Bay, Plan_Volume_Position, Parametr); // Stop_Bay - точка выхода из продаж в Cash (убыточная)
QUIK.Consructor_Transactiy(2, 1, z_Bay, Plan_Volume_Position, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
QUIK.Consructor_Transactiy(2, 2, in_Bay, Plan_Volume_Position, Parametr); // in_Bay - точка входа в лонг
}
in_Sell = 0;
Sum_Sdelok++;
Open_Position = Buf_in_Sell;
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
}
// если мы SHORT
// цена поднимается до уровня передвижения стопа +1 по RENKO
if (Vector_Position == Sell & Chislo_out[8] >= Shag_Sell & Chislo_out[7] == 1)
{
in_Bay = Stop_Sell_2;
z_Bay = Stop_Sell_2;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(20, 1, 0, 0, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
QUIK.Consructor_Transactiy(20, 2, 0, 0, Parametr); // in_Bay - точка входа в лонг
// теперь выставляем нужные
QUIK.Consructor_Transactiy(2, 1, z_Bay, Plan_Volume_Position, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
QUIK.Consructor_Transactiy(2, 2, in_Bay, Plan_Volume_Position, Parametr); // in_Bay - точка входа в лонг
}
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
}
// если мы в LONG
// цена опускается до уровня передвижения стопа -1 по RENKO
if (Vector_Position == Bay & Chislo_out[8] <= Shag_Bay & Chislo_out[7] == 1)
{
in_Sell = Stop_Bay_2;
z_Sell = Stop_Bay_2;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(19, 1, 0, 0, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(19, 2, 0, 0, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(1, 1, in_Sell, Plan_Volume_Position, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(1, 2, z_Sell, Plan_Volume_Position, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
}
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
}
// если мы в SHORT
// цена поднимается до уровня выхода в CASH
if (Vector_Position == Sell & Chislo_out[4] >= Stop_Bay)
{
Vector_Position = Cash;
Volume_Position = 0;
Shag_Sell = 0;
in_Sell = 0;
Buf_in_Sell = 0;
z_Bay = 0;
Buf_z_Bay = 0;
in_Bay = Stop_Sell_2;
Sum_Sdelok++;
Close_Position = Stop_Bay;
Local_Profit = Local_Profit + (Open_Position - Close_Position);
Rezultat_Sdelki = (Open_Position - Close_Position) / Visota_Kanala;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(19, 1, 0, 0, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay - точка выхода из продаж в Cash (убыточная)
QUIK.Consructor_Transactiy(20, 1, 0, 0, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
QUIK.Consructor_Transactiy(20, 2, 0, 0, Parametr); // in_Bay - точка входа в лонг
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell - точка выхода из покупок в Cash (убыточная)
QUIK.Consructor_Transactiy(19, 2, 0, 0, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(2, 2, in_Bay, Plan_Volume_Position, Parametr); // in_Bay - точка входа в лонг
}
Stop_Bay = 0;
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
}
// если мы в LONG
// цена опускается до уровня выхода в CASH
if (Vector_Position == Bay & Chislo_out[5] <= Stop_Sell)
{
Vector_Position = Cash;
Volume_Position = 0;
Shag_Bay = 0;
in_Bay = 0;
Buf_in_Bay = 0;
z_Sell = 0;
Buf_z_Sell = 0;
in_Sell = Stop_Bay_2;
Sum_Sdelok++;
Close_Position = Stop_Sell;
Local_Profit = Local_Profit + (Close_Position - Open_Position);
Rezultat_Sdelki = (Close_Position - Open_Position) / Visota_Kanala;
if (Regim_Rabota == 1 & sistem_vector == 2) // если у нас включен торговый режим
{
// int COD_Transactions_x, int COD_Transactions_z, decimal PRICE, int QUANTITY
// в начале все снимаем
QUIK.Consructor_Transactiy(19, 1, 0, 0, Parametr); // in_Sell - точка входа в шорт
QUIK.Consructor_Transactiy(29, 1, 0, 0, Parametr); // Stop_Bay - точка выхода из продаж в Cash (убыточная)
QUIK.Consructor_Transactiy(20, 1, 0, 0, Parametr); // z_Bay - точка выхода из продаж в Cash (прибыльная)
QUIK.Consructor_Transactiy(20, 2, 0, 0, Parametr); // in_Bay - точка входа в лонг
QUIK.Consructor_Transactiy(28, 1, 0, 0, Parametr); // Stop_Sell - точка выхода из покупок в Cash (убыточная)
QUIK.Consructor_Transactiy(19, 2, 0, 0, Parametr); // z_Sell = 0 - точка выхода из покупок в Cash (прибыльная)
// теперь выставляем нужные
QUIK.Consructor_Transactiy(1, 1, in_Sell, Plan_Volume_Position, Parametr); // in_Sell - точка входа в шорт
}
Stop_Sell = 0;
if (Regim_Rabota == 1 & sistem_vector == 2)
{
// выводим данные на консоль
Console.WriteLine(
"xR01" + " " +
Chislo_out[1] + " " +
Chislo_out[2] + " " +
"Vector_Position: " + Vector_Position + " " +
"Volume_Position: " + Volume_Position + " " +
"InSell: " + in_Sell + " " +
"SpotBuy: " + Stop_Bay + " " +
"z_Buy: " + z_Bay + " " +
"in_Buy: " + in_Bay + " " +
"Stop_Sell: " + Stop_Sell + " " +
"z_Sell: " + z_Sell
);// выводим приказ на консоль
}
if (Regim_Rabota == 1 & sistem_vector == 2)
{
QUIK.Consructor_Transactiy(0, 1, 0, 0, Parametr); // вызов функции перенесения заявок
}
}
// рассчет оценки рисков //
if (Max_Profit < Local_Profit) // расчет планки максимального капитала
{
Max_Profit = Local_Profit;
}
Local_Drogdawn = Local_Profit - Max_Profit - 0.001m; //рассчет локальной просадки
if (Max_Drogdawn > Local_Drogdawn) // расчет планки максимальной просадки
{
Max_Drogdawn = Local_Drogdawn;
}
if (Max_Drogdawn != 0)// расчет доли от максимальной просадки
{
Doli_Drogdawn = Local_Drogdawn / Max_Drogdawn;
}
str_x = "." + Sum_Sdelok.ToString() + "." + Vector_Position.ToString() + "." + Open_Position.ToString() + "." + Close_Position.ToString()
+ "." + Stop_Sell.ToString() + "." + Shag_Bay.ToString() + "." + z_Sell.ToString()
+ "." + z_Bay.ToString() + "." + Shag_Sell.ToString() + "." + Stop_Bay.ToString()
+ "." + Rezultat_Sdelki.ToString() + "." + Local_Profit.ToString() + "." + Max_Profit.ToString() + "." + Local_Drogdawn.ToString() + "." + Max_Drogdawn.ToString()
+ "." + Doli_Drogdawn.ToString() + "." + sistem_vector.ToString();
Rezerv_Rezultat_Sdelki = Rezultat_Sdelki * Visota_Kanala;
Rezultat_Sdelki = 0;
return(0);
}
public void Write_Excel(string name, string[] Reestr, int y, Parametrs Parametr)
{
// Сам сервер - объект Application или приложение Excel,
// может содержать одну или более книг, ссылки на которые содержит свойство Workbooks.
// Книги - объекты Workbook, могут содержать одну или более страниц,
// ссылки на которые содержит свойство Worksheets или (и) диаграмм - свойство Charts.
// Страницы - Worksheet, содержать объекты ячейки или группы ячеек,
// ссылки на которые становятся доступными через объект Range.
// Ниже в иерархии: строки, столбцы... Аналогично и для объекта Chart серии линий, легенды...
//Process Ex1 = new Process();
//Thread Thread = new System.Threading.Thread();
//Thread.
int x = Parametr.stroka; // индексатор строк в екселе
// y - индексатор столбцов в екселе
int i = 1; // индексатор массива
Application xlApp = new ApplicationClass();
Workbook xlWorkBook;
Worksheet xlWorkSheet;
object misValue = System.Reflection.Missing.Value;
string[] General_Directory = Directory.GetCurrentDirectory().Split(new char[] { '\\' }); // корневая директория с EXE файлом
string filePath = General_Directory[0] + Parametr.Excel_Path;
//Если не существует файла то создать его
bool isFileExist;
FileInfo fInfo = new FileInfo(filePath);
if (!fInfo.Exists)
{
xlWorkBook = xlApp.Workbooks.Add(misValue); //Добавить новый book в файл
isFileExist = false;
}
else
{
//Открыть существующий файл
xlWorkBook = xlApp.Workbooks.Open(
filePath, // FileName - Имя открываемого файла
0, // UpdateLinks - Способ обновления ссылок в файле
false, // ReadOnly - При значении true открытие только для чтения
5, // Format - Определение формата символа разделителя
"", // Password - Пароль доступа к файлу до 15 символов
"", // WriteResPassword - Пароль на сохранение файла
true, // IgnoreReadOnlyRecommended - При значении true отключается вывод //запроса на работу без внесения изменений
XlPlatform.xlWindows, // Origin - Тип текстового файла
"\t", // Delimiter - Разделитель при Format = 6
false, // Editable - Используется только для надстроек Excel 4.0
true, // Notify - При значении true имя файла добавляется в //список нотификации файлов
0, // Converter - Используется для передачи индекса конвертера файла //используемого для открытия файла
true, // AddToMRU - При true имя файла добавляется в список //открытых файлов
1,
0);
// UpdateLinks - позволяет задать способ обновления ссылок в файле.
// Если данный параметр не задан, то выдается запрос на указание метода обновления.
// Значения: 0 - не обновлять ссылки; 1 - обновлять внешние ссылки; 2 - обновлять только удаленные ссылки; 3 - обновлять все ссылки.
// Format - при работе с текстовыми файлами определяет символ разделителя для полей, заносимых в различные ячейки документа.
// Значения параметра: 1 - символ табуляции; 2 - запятая; 3 - пробел; 4 - точка с запятой; 5 - нет разделителя; 6 - другой символ, определенный в параметре Delimiter.
isFileExist = true;
}
xlWorkSheet = (Worksheet)xlWorkBook.Worksheets.get_Item(Parametr.list); //Открытие вкладки "1_min"
//БЛОК ЗАПОЛНЕНИЯ ФАЙЛА
xlWorkSheet.Cells[x, y] = Parametr.zagolovok_visota_kanala; // высота канала
x++;
xlWorkSheet.Cells[x, y] = Parametr.zagolovok_stolbca; // таймфрейм
x++;
xlWorkSheet.Cells[x, y] = name; // заголовок вариации систему управления капиталом
x++;
while (i != 29)
{
xlWorkSheet.Cells[x, y] = Reestr[i]; //Запись значения в ряд = x, столбец = y
x++;
i++;
}
x = 1;
i = 0;
//Получить количество используемых столбцов
//int columnsCount = xlWorkSheet.UsedRange.Columns.Count;
//Получить количество используемых строк
//int usedRowsCount = xlWorkSheet.UsedRange.Rows.Count;
//Если файл существовал, просто сохранить его по умолчанию. Иначе сохранить в указанную директорию
if (isFileExist)
{
xlWorkBook.Save();
}
else
{
xlWorkBook.SaveAs(filePath, XlFileFormat.xlWorkbookNormal, misValue, misValue, misValue,
misValue, XlSaveAsAccessMode.xlExclusive, misValue, misValue, misValue, misValue, misValue);
}
xlApp.Visible = true;
xlWorkBook.Close(true, misValue, misValue);
xlApp.Quit();
//БЛОК АНАЛИТИКИ ПО ОТКРЫТЫМ ПРОЦЕССАМ
//Process[] myProcesses2 = Process.GetProcesses();
//foreach (Process myProcess in myProcesses2)
//{
//Console.WriteLine(myProcess.ProcessName);
//}
//БЛОК ЗАКРЫТИЯ ВСЕХ ПРОЦЕССОВ EXCEL
Process[] myProcesses;
// Returns array containing all instances of Notepad.
myProcesses = Process.GetProcessesByName("Excel");
foreach (Process myProcess in myProcesses)
{
myProcess.Kill();
}
}
public StreamWriter ExPort_File_Metod(Parametrs Parametr) // открытие файла для записи
{
string[] General_Directory = Directory.GetCurrentDirectory().Split(new char[] { '\\' }); // корневая директория с EXE файлом
fstr_out = new StreamWriter(General_Directory[0] + Parametr.File_ExPort);
return(fstr_out);
}
public int index_end_file = 0; // индекс конца текстового файла
public StreamReader Open_File(Parametrs Parametr) // метод по открытию файла
{
string[] General_Directory = Directory.GetCurrentDirectory().Split(new char[] { '\\' }); // корневая директория с EXE файлом
fileReader = new StreamReader(General_Directory[0] + Parametr.File_ExPort);
return(fileReader);
}
public OleDbDataReader Read_Access(OleDbConnection myOleDbConnection, OleDbCommand myOleDbCommand, Parametrs Parametr) // метод по чтению данных из базы
{
//ищем первую строку в нашей базе:
if (AAA == 0)
{
myOleDbCommand.CommandText =
"SELECT Top 1 Index " + // сюда прописываем название столбцов в таблице базы данных(обращаем внимание на пробелы)
"FROM " + Parametr.Baza; // сюда прописывается сортируемое слово
myOleDbDataReader = myOleDbCommand.ExecuteReader();
myOleDbDataReader.Read();
if (myOleDbDataReader.HasRows != false)
{
nomer_sdelki = int.Parse(myOleDbDataReader["Index"].ToString());
myOleDbDataReader.Close();// закрываем OleDbDataReader методом Close()
AAA++;
}
}
// организуем цикл считывания данных из базы access
if (nomer_sdelki != 0)
{
filter = x + nomer_sdelki.ToString(); // создаем часть запроса на поиск индексируемой строки
// задаем SQL-запрос к базе данных в свойстве CommandText объекта OleDbCommand
// Результатом запроса должны быть данные клинета с именем Кто-то
myOleDbCommand.CommandText =
"SELECT Nomer, Data, Vrema, Bymaga, Cena " + // сюда прописываем название столбцов в таблице базы данных(обращаем внимание на пробелы)
"FROM " + Parametr.Baza + " " + // сюда прописываем название таблицы в базе данных
filter; // сюда прописывается сортируемое слово
// присваиваем объекту OleDbDataReader и вызываем метод ExecuteReader() для выполнения введенного SQL-запроса
myOleDbDataReader = myOleDbCommand.ExecuteReader();
// Читаем строку ответа базы данных с помощью метода Read() объекта OleDbDataReader
myOleDbDataReader.Read();
// отображаем результат запроса
// с проверкой на наличие в таблице данных по номеру индекса
if (myOleDbDataReader.HasRows != false)
{
// записываем результаты в переменные.
// эти данные служат для вывода в бот.
// точка подключения торгового ядра
e = myOleDbDataReader["Bymaga"].ToString();
d = myOleDbDataReader["Data"].ToString();
a = myOleDbDataReader["Nomer"].ToString();
b = myOleDbDataReader["Vrema"].ToString();
c = myOleDbDataReader["Cena"].ToString();
Nomer = int.Parse(a); //преобразуем номер сделки последней считанной транзакции в число
Cena = decimal.Parse(c); // преобразуем цену последней считанной транзакции в число
taymer = b.Split(new char[] { ':' }); // установка разделителя строки на столбцы и запись в массив
// массив данных содержит время последней обработанной транзакции
taymer_out[0] = int.Parse(taymer[0]);
taymer_out[1] = int.Parse(taymer[1]);
taymer_out[2] = int.Parse(taymer[2]);
taymer_out[3] = taymer_out[0] * 60 * 60 + taymer_out[1] * 60 + taymer_out[2]; // время последней транзакции в секундах
//***********************строим свечку********************//
// Cena - цена последней транзации
// Nomer - номер сделки последней транзакции
// taymer_out[3] - время в секундах последней транзакции
// Chislo_out[0] = таймфрейм
// Chislo_out[1] = дата
// Chislo_out[2] = время
// Chislo_out[3] = open
// Chislo_out[4] = max
// Chislo_out[5] = min
// Chislo_out[6] = close
// Chislo_out[7] = index индекс показывает равно ли время предыдущей свечи
// Chislo_out[8] = last close
// Start_Market = 36000
// Taym_Freym = 300
// Taym_Open
// Taym_Close
if (taymer_out[3] >= Taym_Open & taymer_out[3] < (Taym_Close))
{
// расчет текущей свечи, заполняем данные
Chislo_out[0] = Parametr.Taym_Freym;
Chislo_out[1] = a1.Metod_Reconvertor_Data(d);
Chislo_out[2] = a1.Metod_Reconvertor_Time(Taym_Open);// преобразуем время в нужный формат
if (taymer_out[3] == Taym_Open & Chislo_out[3] == 0)
{
// случай для пустой свечи
Chislo_out[3] = Cena; // рассчитываем цену открытия
Chislo_out[4] = Cena;
Chislo_out[5] = Cena;
Chislo_out[6] = Cena;
}
else
{
// случай для непустой свечи
if (Cena > Chislo_out[4])
{
Chislo_out[4] = Cena; // рассчитываем максимум
}
if (Cena < Chislo_out[5])
{
Chislo_out[5] = Cena; // рассчитываем минимум
}
Chislo_out[6] = Cena; // обновляем последнюю сделку
}
}
else // если время таймфрейма для свечки подошло к концу, начинаем строим новую свечу
{
// сдвигаем тайфрейм пока не найдем нужный интервал
while (taymer_out[3] > Taym_Open & taymer_out[3] >= (Taym_Close))
{
Taym_Open = Taym_Open + Parametr.Taym_Freym;
Taym_Close = Taym_Close + Parametr.Taym_Freym;
}
// !!! нужно обнулить свечу, в нее идут новые данные
Chislo_out[2] = a1.Metod_Reconvertor_Time(Taym_Open);
Chislo_out[3] = Cena;
Chislo_out[4] = Cena;
Chislo_out[5] = Cena;
Chislo_out[6] = Cena;
}
// Chislo_out[0] = таймфрейм
// Chislo_out[1] = дата
// Chislo_out[2] = время
// Chislo_out[3] = open
// Chislo_out[4] = max
// Chislo_out[5] = min
// Chislo_out[6] = close
// Chisli_out[7] = index индекс показывает равно ли время предыдущей свечи
// Chislo_out[8] = last close
// записываем резервную свечу
Chislo_out[8] = Chislo_out_reserv[6];
if (Chislo_out[2] != Chislo_out_reserv[2] & Chislo_out_reserv[2] != 0)
{
Chislo_out[7] = 1; // если равно еденица, значит свечка сформированна
// записываем свечку в файл
// Chislo_out[0] = таймфрейм
// Chislo_out[1] = дата
// Chislo_out[2] = время
// Chislo_out[3] = open
// Chislo_out[4] = max
// Chislo_out[5] = min
// Chislo_out[6] = close
// Chislo_out[7] = index индекс показывает равно ли время предыдущей свечи
// Chislo_out[8] = last close
// e = бумага
// преобразуем данные в строку вида:
// формат данных: SPFB.RTS,30,20120525,100000,127160.00000,127980.00000,126300.00000,127770.00000
stroka = e + "," + Chislo_out_reserv[0].ToString() + "," +
Chislo_out_reserv[1].ToString() + "," +
Chislo_out_reserv[2].ToString() + "," +
Chislo_out_reserv[3].ToString() + "," +
Chislo_out_reserv[4].ToString() + "," +
Chislo_out_reserv[5].ToString() + "," +
Chislo_out_reserv[6].ToString();
a2.Do_ExPort_File(Parametr, stroka);
}
else
{
Chislo_out[7] = 0;
}
Chislo_out_reserv[0] = Chislo_out[0];
Chislo_out_reserv[1] = Chislo_out[1];
Chislo_out_reserv[2] = Chislo_out[2];
Chislo_out_reserv[3] = Chislo_out[3];
Chislo_out_reserv[4] = Chislo_out[4];
Chislo_out_reserv[5] = Chislo_out[5];
Chislo_out_reserv[6] = Chislo_out[6];
Chislo_out_reserv[7] = Chislo_out[7];
Chislo_out_reserv[8] = Chislo_out[8];
// выводим данные
//Console.WriteLine(
// //myOleDbDataReader["Nomer"] + " " + // воводим данные из ячейки в столбце ...
//myOleDbDataReader["Vrema"] + " " + // воводим данные из ячейки в столбце ...
//myOleDbDataReader["Cena"] + " " + // воводим данные из ячейки в столбце ...
//Chislo_out[0] + " " +
// //Chislo_out[1] + " " +
//Chislo_out[2] + " " +
//Chislo_out[3] + " " +
//Chislo_out[4] + " " +
//Chislo_out[5] + " " +
//Chislo_out[6] + " " +
//Chislo_out[7] + " " +
//Chislo_out[8]
//);
nomer_sdelki++; // увеличиваем значение индексируемого столбца на +1
}
// закрываем OleDbDataReader методом Close()
myOleDbDataReader.Close();
}
return(myOleDbDataReader);
}