public void TestTradesToday()
{
//string filename = "today_trades.txt";
string fileSummary = "summary.xls";
string fileVariability = "variability.txt";
string fileBrutto = "brutto.txt";
string fileBruttoFiltr = "brutto_filtr.txt";
string fileBruttoFiltrPro = "brutto_filtr_pro.txt";
string fileTrades = "trades.txt";
MarketTradesRepository mTR = new MarketTradesRepository();
TradesBolingerRepository tBR = new TradesBolingerRepository();
mTR = (MarketTradesRepository)StaticService.Deserializes(mTR.GetType().ToString(), mTR);
tBR = (TradesBolingerRepository)StaticService.Deserializes("09.11.2016_070008", tBR);
//for (int i = 3; i <= 3; i++)
//{
// CalculationExtremumPrice(mTR, i, filename);
//}
StaticService.DeleteFile(fileSummary);
StaticService.DeleteFile(fileVariability);
StaticService.DeleteFile(fileTrades);
StaticService.DeleteFile(fileBruttoFiltr);
StaticService.DeleteFile(fileBruttoFiltrPro);
StaticService.LogFileWriteNotDateTime("Profit sett\tProfit\tCount profit\tCount loss\tCount all", fileSummary, true);
// оптимизация по профиту
for (int i = 5; i <= 5; i++)
{
CalculationExtremumProfit(mTR, tBR, 5, i, fileSummary, fileTrades, fileVariability, fileBrutto, fileBruttoFiltr, fileBruttoFiltrPro);
}
}
/// <summary>
/// Асинхронный вызов CalculationExtremumPrice
/// </summary>
private Task <string> TaskCalculationString(MarketTradesRepository mTR, ExtremumPrice _extPrice, decimal i, decimal ii, decimal iii)
{
return(Task.Run(() =>
{
return CalcExtremPriceString(mTR, _extPrice, i, ii, iii, true);
}));
}
// Вызов поиска экстремумов и вызов поиска экстремумов с дистанцией
private string CalculationExtremumPrice(MarketTradesRepository _mTR, decimal _otkat, decimal _distance, decimal _profit, bool _write_trades)
{
ExtremumPrice _extPrice = new ExtremumPrice();
_extPrice.CreateExtrem(_mTR, _otkat);
return(_extPrice.CreateExtremDistance(_mTR, _otkat, _distance, _profit, _write_trades));
}
/// <summary>
/// Запуск поиска экстремумов
/// </summary>
public void CreateExtrem(MarketTradesRepository _mTR, decimal _otkat)
{
foreach (var item in _mTR)
{
this.ExtremumSearch(item.PriceTrades, item.DateTimeTrades, _otkat);
}
}
private void ExtremumDistanceProcess(MarketTradesRepository _mTR, decimal _otkat, decimal _distance, decimal _profit, bool _write_trades)
{
foreach (var item in _mTR)
{
this.ExtremumSearchDistance(item.PriceTrades, item.DateTimeTrades, _otkat, _distance, _profit, _write_trades);
}
}
private Task <ResultExtremDistance> TaskCalculation(MarketTradesRepository mTR, decimal i, decimal ii, decimal iii)
{
return(Task.Run(() =>
{
return CalculationExtremumPrice(mTR, i, ii, iii, false);
}));
}
/// <summary>
/// Расчет Болинжера по _countPeriod и _kstd
/// </summary>
private async Task CreateRepositoryBolinger(MarketTradesRepository _mtr, int _countPeriod, double _kstd, string _fileNameInp)
{
double High_line = 0;
double Midl_line = 0;
double Low_line = 0;
double price;
List <double> priceList = new List <double>();
TradesBolingerRepository _trdBReposit = new TradesBolingerRepository();
await Task.Run(() =>
{
foreach (ParametrMarketTrades item in _mtr)
{
price = (double)item.PriceTrades;
priceList.Add(price);
if (priceList.Count == _countPeriod)
{
StaticCalculations.BollingerBands(priceList, _kstd, ref High_line, ref Midl_line, ref Low_line);
priceList.RemoveAt(0);
_trdBReposit.Add(new ParametrTradesBolinger(item.DateTimeTrades, item.NumberTrades, item.PriceTrades, item.SeccodeTrades, High_line, Low_line, Midl_line));
}
}
string _fileName = _fileNameInp + StaticService.GenerateKey(_countPeriod, _kstd);
StaticService.Serializes(_trdBReposit, folderOut + _fileName);
});
}
/// <summary>
/// Запуск расчета Болинжера по множеству параметров
/// </summary>
private async Task TaskMultiParametrBB(string _path, SettingsClass _sc)
{
MarketTradesRepository _marketTrad = (MarketTradesRepository)StaticService.Deserializes(_path);
List <Task> tasks = new List <Task>();
int countPeriod = _sc.CountPeriodBB_Start;
double k_stddev;
string _fileNameInp = Path.GetFileNameWithoutExtension(_path) + "_";
for (int i = 0; i < _sc.CountStepPeriod; i++)
{
k_stddev = _sc.CountStdDevBB_Start;
for (int ii = 0; ii < _sc.CountStepStdDev; ii++)
{
Task theTask = CreateRepositoryBolinger(_marketTrad, countPeriod, k_stddev, _fileNameInp);
tasks.Add(theTask);
k_stddev += _sc.StdDevBBStep;
}
countPeriod += _sc.PeriodBBStep;
}
await Task.WhenAll(tasks);
}
public ObtainingDriver(RepositiryClasses _rC)
{
_allTradChannel = (AllTradesChannel)_rC.GetReference("AllTradesChannel");
_allTradChannel.LoadedLineEvent += _allTradChannel_LoadedLineEvent;
marketTradRepo = _rC.MarketTradRepo;
settClass = _rC.SettClass;
id = 0;
}
//--------------
/// <summary>
/// Запуск поиска экстремумов
/// </summary>
public void CreateExtrem(MarketTradesRepository _mTR, decimal _otkat, decimal _profit)
{
position = 0;
num_trades = 0;
foreach (var item in _mTR)
{
this.ExtremumSearch(item.PriceTrades, item.DateTimeTrades, _otkat, _profit);
}
}
}//----------------
/// <summary>
/// Запуск поиска экстремумов с дистанцией
/// Возвращает ResultExtremDistance
/// </summary>
public ResultExtremDistance CreateExtremDistanceResult(MarketTradesRepository _mTR, decimal _otkat, decimal _distance, decimal _profit, bool _write_trades)
{
ExtremumDistanceProcess(_mTR, _otkat, _distance, _profit, _write_trades);
if (base.EqCurrent > 0 && base.CountTrades > 0)
{
return(new ResultExtremDistance(base.EqCurrent, base.Drawdown, _otkat, _distance, _profit));
}
return(new ResultExtremDistance());
}
public string CreateExtremDistance(MarketTradesRepository _mTR, decimal _otkat, decimal _distance, decimal _profit, bool _write_trades, TimeSpan _starttime, TimeSpan _finishtime)
{
string _result = String.Empty;
ExtremumDistanceProcess(_mTR, _otkat, _distance, _profit, _write_trades, _starttime, _finishtime);
if (base.CountTrades > 0)
{
_result = base.EqCurrent + "\t" + base.CountTrades + "\t" + base.CountProfit + "\t" + base.CountLoss + "\t" + base.Drawdown + "\t" + _otkat + "\t" + _distance + "\t" + _profit + "\n";
}
return(_result);
}//----------------
//---------
private MarketTradesRepository ResWhereTime(MarketTradesRepository mTR, TimeSpan _start, TimeSpan _finish)
{
IEnumerable <ParametrMarketTrades> _whereRes = mTR.Where(x => x.DateTimeTrades.TimeOfDay >= _start && x.DateTimeTrades.TimeOfDay <= _finish);
MarketTradesRepository _mtr_range = new MarketTradesRepository();
foreach (ParametrMarketTrades item in _whereRes)
{
_mtr_range.Add(item);
}
return(_mtr_range);
}
public async Task TestTradesTodayAsync()
{
string _result_test = String.Empty;
TimeSpan _runTime;
DateTime _startRun = DateTime.Now;
decimal otkat = 30;
decimal distance = 30;
decimal profit = 30;
List <Task <string> > tasks = new List <Task <string> >();
MarketTradesRepository mTR = new MarketTradesRepository();
mTR = (MarketTradesRepository)StaticService.Deserializes(mTR.GetType().ToString(), mTR);
StaticService.DeleteFile("trade_log.txt");
StaticService.DeleteFile("equ.txt");
StaticService.LogFileWriteNotDateTime("EqCurrent\tCountTrades\tCountProfit\tCountLoss\tDrawdown\t_otkat\t_distance\t_profit", "equ.txt", true);
for (int i = (int)otkat; i <= 200; i += 10)
{
for (int ii = i; ii <= 200; ii += 10)
{
for (int iii = i; iii <= 200; iii += 10)
{
//ExtremumPrice _extPrice2 = new ExtremumPrice();
//CalculationExtremumPrice1(mTR, _extPrice2, i, ii, iii, false);
Task <string> theTask = TaskCalculation(mTR, i, ii, iii);
tasks.Add(theTask);
}
}
}
await Task <string> .WhenAll(tasks);
foreach (Task <string> item in tasks)
{
_result_test += item.Result;
}
_runTime = DateTime.Now - _startRun;
StaticService.LogFileWriteNotDateTime(String.Format("{0:00}:{1:00}:{2:00}.{3:000}", _runTime.Hours, _runTime.Minutes, _runTime.Seconds, _runTime.Milliseconds), "runtime.txt", true);
StaticService.LogFileWriteNotDateTime(_result_test, "equ.txt", true);
}
/// <summary>
/// Прогон по единичным параметрам
/// </summary>
public ExtremumPrice TestTradesToday1()
{
decimal otkat = 80;
decimal distance = 190;
decimal profit = 170;
MarketTradesRepository mTR = new MarketTradesRepository();
mTR = (MarketTradesRepository)StaticService.Deserializes(mTR.GetType().ToString(), mTR);
StaticService.DeleteFile("trade_log.txt");
StaticService.DeleteFile("equ.txt");
return(CalculationExtremumPrice1(mTR, otkat, distance, profit, true));
}
/// <summary>
/// Task для конвертации в .dat
/// </summary>
private Task TaskConvert(byte[] _result, string _id)
{
StaticService.LogFileWrite(DateTime.Now.ToLongTimeString() + " " + _id, "runtime.txt", true);
return(Task.Run(() =>
{
string _text = Encoding.UTF8.GetString(_result);
string[] _separator = new string[3] {
"\r\n", "\n", "\r"
};
string[] _mapStr = _text.Split(_separator, StringSplitOptions.RemoveEmptyEntries);
string _date = String.Empty;
string _time = String.Empty;
decimal _price = 0;
MarketTradesRepository marketTradRepo = new MarketTradesRepository();
int _iD = 0;
foreach (string _line in _mapStr)
{
string[] _splites = Regex.Split(_line, paternRegEx1);
_iD++;
_date = _splites[0];
_time = _splites[1];
try
{
_price = Convert.ToDecimal(_splites[2]);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
marketTradRepo.Add(new ParametrMarketTrades(_iD.ToString(), _date, _time, 0, _price, ""));
}
if (marketTradRepo.Count > 0)
{
StaticService.Serializes(marketTradRepo, folder + marketTradRepo[0].DateTimeTrades.ToShortDateString());
}
StaticService.LogFileWrite(DateTime.Now.ToLongTimeString() + " " + _id, "runtime.txt", true);
}));
}
/// <summary>
/// Синхронная конвертация в .dat
/// </summary>
private void ConvertMy()
{
StreamReader file;
string[] filePathes = StaticService.GetPathFiles(folder, patern1);
foreach (string _path in filePathes) // проходим по файлам
{
MarketTradesRepository marketTradRepo;
string _date = String.Empty;
string _time = String.Empty;
decimal _price = 0;
using (file = new StreamReader(_path))
{
string line;
marketTradRepo = new MarketTradesRepository();
int _id = 0;
while ((line = file.ReadLine()) != null) // проходим по стркам
{
string[] _splites = Regex.Split(line, paternRegEx1);
_id++;
_date = _splites[0];
_time = _splites[1];
try
{
_price = Convert.ToDecimal(_splites[2]);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
marketTradRepo.Add(new ParametrMarketTrades(_id.ToString(), _date, _time, 0, _price, ""));
}
}
if (marketTradRepo.Count > 0)
{
StaticService.Serializes(marketTradRepo, folder + marketTradRepo[0].DateTimeTrades.ToShortDateString());
}
}
}
// Просто по экстремумам
private void CalculationExtremumPrice(MarketTradesRepository _mTR, decimal _otkat, string _filename)
{
ExtremumPrice extPrice = new ExtremumPrice();
decimal exchange_fee = 0.47m; // биржевой сбор SBRF 0.47
decimal brokerage_commission = 0.59m; // комиссия брокера 0.59
decimal spred = 3m;
// находим екстремумы
extPrice.CreateExtrem(_mTR, _otkat);
//StaticService.LogFileWrite("----------------Extremums--------------------", _filename, true);
//foreach (var item in extPrice.Extremums)
//{
// StaticService.LogFileWriteNotDateTime(item.Date_Time + "\t" + item.PriceHigh + "\t" + item.PriceLow, _filename, true);
//}
// считаем между ними дельту
//StaticService.LogFileWrite("\n", filename, true);
//StaticService.LogFileWriteNotDateTime("----------------считаем между ними дельту--------------------", _filename, true);
extPrice.DeltaExtr();
foreach (var item in extPrice.DeltaExtremums)
{
StaticService.LogFileWriteNotDateTime(Math.Abs(item).ToString(), "delta_log.txt", true);
}
StaticService.LogFileWriteNotDateTime("****************ОТКАТ <" + _otkat + ">****************", _filename, true);
//&??????????????????
for (decimal i = _otkat * 2; i <= _otkat * 8; i++)
{
decimal criticalSum = 0;
// фильтруeм дельты
StaticService.LogFileWriteNotDateTime("----------------фильтруeм дельты <" + i + ">--------------------", _filename, true);
extPrice.FiltrDelta(i);
foreach (var item in extPrice.FiltrDeltas)
{
StaticService.LogFileWriteNotDateTime(Math.Abs(item).ToString(), _filename, true);
criticalSum += Math.Abs(item) - (_otkat * 2 + TransactionCosts(exchange_fee, brokerage_commission, spred) * 2);
}
StaticService.LogFileWriteNotDateTime(criticalSum.ToString(), _filename, true);
}
}
public RepositiryClasses()
{
DDEChannelCreate();
// --1--
marketTradesRepository = new MarketTradesRepository();
testResultRepository = new TestResultRepositiry();
settingsClass = new SettingsClass();
// --2--
// восстанавливаем сохраненные экземпляры
DeserializesObject();
// последний
obtainingDriver = new ObtainingDriver(this);
convertToDat = new ConvertToDat();
calcBolinger = new CalculationBolinger();
testMarketDriver = new TestMarketDriver();
}
public void CreateExtrem(MarketTradesRepository _mTR, decimal _otkat, TimeSpan _starttime, TimeSpan _finishtime)
{
bool _search = false;
TimeSpan _time_trades;
foreach (var item in _mTR)
{
_time_trades = item.DateTimeTrades.TimeOfDay;
if (_time_trades > _starttime && _time_trades < _finishtime)
{
this.ExtremumSearch(item.PriceTrades, item.DateTimeTrades, _otkat);
_search = true;
}
if (_time_trades > _finishtime && _search)
{
break;
}
}
}//--------------------------
//----
private void ExtremumDistanceProcess(MarketTradesRepository _mTR, decimal _otkat, decimal _distance, decimal _profit, bool _write_trades, TimeSpan _starttime, TimeSpan _finishtime)
{
bool _search = false;
TimeSpan _time_trades;
foreach (var item in _mTR)
{
_time_trades = item.DateTimeTrades.TimeOfDay;
if (_time_trades > _starttime && _time_trades < _finishtime)
{
this.ExtremumSearchDistance(item.PriceTrades, item.DateTimeTrades, _otkat, _distance, _profit, _write_trades);
_search = true;
}
if (_time_trades > _finishtime && _search)
{
break;
}
}
}
//--------
#region -Constructor-
public ViewModel()
{
repositClasses = new RepositiryClasses();
manipulationCharts = new ManipulationCharts();
marketTradRepo = repositClasses.MarketTradRepo;
testResultBufer = repositClasses.TestResReposit;
settingsClass = repositClasses.SettClass;
testMarketDriver = repositClasses.TestmarketDriver;
intraAdapt = new IntradayAdaptation();
// работа через файлы
convertToDat = repositClasses.ConvToDat;
calcBolinger = repositClasses.CalcBolinger;
fromDate = DateTime.Now;
toDate = fromDate;
oneDay = fromDate;
countBest = 1;
}
/// <summary>
/// Вызов поиска экстремумов и вызов поиска экстремумов с дистанцией
/// </summary>
private string CalcExtremPriceString(MarketTradesRepository _mTR, ExtremumPrice _extPrice, decimal _otkat, decimal _distance, decimal _profit, bool _write_trades)
{
//_extPrice.CreateExtrem(_mTR, _otkat);
return(_extPrice.CreateExtremDistance(_mTR, _otkat, _distance, _profit, _write_trades));
}
public async Task AdaptationAsync()
{
string _result_test = String.Empty;
TimeSpan _runTime;
DateTime _startRun = DateTime.Now;
TimeSpan steptime = new TimeSpan(2, 0, 0);
TimeSpan steptime1 = new TimeSpan(2, 0, 0);
TimeSpan starttime = new TimeSpan(10, 1, 0).Subtract(steptime1);
TimeSpan finishtime = starttime.Add(steptime);
TimeSpan stoptime = new TimeSpan(19, 0, 0);
decimal otkat = 30;
decimal distance = 30;
decimal profit = 30;
MarketTradesRepository mTR = new MarketTradesRepository();
mTR = (MarketTradesRepository)StaticService.Deserializes(mTR.GetType().ToString(), mTR);
ExtremumPrice _extPrice = new ExtremumPrice(); // !!!
StaticService.DeleteFile("trade_log.txt");
StaticService.DeleteFile("equ.txt");
StaticService.DeleteFile("trade_log.txt");
StaticService.DeleteFile("group_log.txt");
StaticService.LogFileWriteNotDateTime("EqCurrent\tCountTrades\tCountProfit\tCountLoss\tDrawdown\t_otkat\t_distance\t_profit", "equ.txt", true);
//StaticService.LogFileWriteNotDateTime("EqCurrent\tDrawdown\t_otkat\t_distance\t_profit", "trade_log.txt", true);
do
{
//-------------------------------------
finishtime = finishtime.Add(steptime1);
starttime = finishtime.Subtract(steptime);
if (finishtime > stoptime)
{
finishtime = stoptime;
}
//--------------------------------------
// I поиск оптимальных параметров
List <Task <ResultExtremDistance> > tasksResult = new List <Task <ResultExtremDistance> >();
List <Task <string> > tasksString = new List <Task <string> >();
List <ResultExtremDistance> resultsExDist = new List <ResultExtremDistance>();
MarketTradesRepository _mtr_range = ResWhereTime(mTR, starttime, finishtime);
for (int i = (int)otkat; i <= 200; i += 10)
{
for (int ii = i; ii <= 200; ii += 10)
{
for (int iii = i; iii <= 200; iii += 10)
{
Task <ResultExtremDistance> theTask = TaskCalculation(_mtr_range, i, ii, iii);
tasksResult.Add(theTask);
}
}
}
await Task <ResultExtremDistance> .WhenAll(tasksResult);
foreach (Task <ResultExtremDistance> item in tasksResult)
{
if (item.Result.otkat > 0)
{
resultsExDist.Add(item.Result);
}
}
// II выборка лучших параметров
ResultExtremDistance _bestResExDist = MyGroupBy(resultsExDist);
/*
* // III следующий интервал торгуем с выбранными параметрами
* MarketTradesRepository _mtr = ResWhereTime(mTR, finishtime, finishtime.Add(steptime1));
*
* StaticService.LogFileWriteNotDateTime("\nParametr\t" + _bestResExDist.eqcurrent + "\t" + _bestResExDist.drawdown + "\t" + _bestResExDist.otkat + "\t" + _bestResExDist.distance + "\t" + _bestResExDist.profit, "trade_log.txt", true);
*
* Task<string> theTaskMarket = TaskCalculationString(_mtr, _extPrice, _bestResExDist.otkat, _bestResExDist.distance, _bestResExDist.profit);
* tasksString.Add(theTaskMarket);
*
* await Task<string>.WhenAll(tasksString);
*
* foreach (Task<string> item in tasksString)
* {
* _result_test += item.Result;
* }*/
}while (finishtime < stoptime);
_runTime = DateTime.Now - _startRun;
StaticService.LogFileWriteNotDateTime(String.Format("{0:00}:{1:00}:{2:00}.{3:000}", _runTime.Hours, _runTime.Minutes, _runTime.Seconds, _runTime.Milliseconds), "runtime.txt", true);
StaticService.LogFileWriteNotDateTime(_result_test, "equ.txt", true);
}
//-------------------------------------------
//
private void CalculationExtremumProfit(MarketTradesRepository _mTR, TradesBolingerRepository _tBR, decimal _otkat, decimal _profit, string _fileSummary, string _fileTrades, string _filevariability, string _fileBrutto, string _fileBruttoFiltr, string _fileBruttoFiltrPro)
{
ExtremumProfit extPrice = new ExtremumProfit();
Queue <decimal> BruttoQue = new Queue <decimal>();
decimal exchange_fee = 0.47m; // биржевой сбор SBRF 0.47
decimal brokerage_commission = 0.59m; // комиссия брокера 0.59
decimal spred = 3m;
// --одновременно можно только один
//extPrice.CreateExtrem(_mTR, _otkat, _profit);
extPrice.CreateExtrem(_tBR, _otkat, _profit);
//-------
//----
decimal _buyMany = 0;
decimal _selMany = 0;
decimal _bruttoGlobal = 0;
int _countProfit = 0;
int _countLoss = 0;
int _countAll = 0;
int _variability = 0;
StaticService.LogFileWriteNotDateTime("Profit setting <" + _profit + ">", _fileTrades, true);
StaticService.LogFileWriteNotDateTime("Profit setting <" + _profit + ">", _filevariability, true);
StaticService.LogFileWriteNotDateTime("Profit setting <" + _profit + ">", _fileBrutto, true);
StaticService.LogFileWriteNotDateTime("Profit setting <" + _profit + ">", _fileBruttoFiltr, true);
StaticService.LogFileWriteNotDateTime("Profit setting <" + _profit + ">", _fileBruttoFiltrPro, true);
foreach (var item in extPrice.TradesQueue)
{
StaticService.LogFileWriteNotDateTime(item.ToString(), _fileTrades, true);
double _num = item.NumberTrades;
Operation _oper = item.Operation;
decimal _price = item.PriceTrades;
decimal _brutto = 0;
if (_oper == Operation.Buuy)
{
_buyMany = _price;
}
else
{
_selMany = _price;
}
if (_buyMany != 0 && _selMany != 0)
{
_brutto = _selMany - _buyMany;
_bruttoGlobal += _brutto;
_buyMany = 0;
_selMany = 0;
if (_brutto > 0)
{
_countProfit++;
}
else
{
_countLoss++;
}
_countAll++;
BruttoQue.Enqueue(_brutto);
StaticService.LogFileWriteNotDateTime(_brutto.ToString(), _fileBrutto, true);
//
VariablityCalc(_brutto, _filevariability, ref _variability);
//-----
}
}
// фильтрация pro
for (int i = 1; i <= 10; i++)
{
Queue <decimal> resultPositive = extPrice.FiltrBruttoPro(BruttoQue, i, 0);
Queue <decimal> resultNegative = extPrice.FiltrBruttoPro(BruttoQue, 0, i);
decimal _sum = 0;
foreach (decimal item in resultPositive)
{
_sum += item;
}
StaticService.LogFileWriteNotDateTime("FILTR_PRO + <" + i + "> = " + _sum.ToString(), _fileBruttoFiltrPro, true);
_sum = 0;
foreach (decimal item in resultNegative)
{
_sum += item;
}
StaticService.LogFileWriteNotDateTime("FILTR_PRO - <" + i + "> = " + _sum.ToString(), _fileBruttoFiltrPro, true);
}
// циклическая фильтрация
StaticService.LogFileWriteNotDateTime("SUMMARY_INP = " + _bruttoGlobal.ToString(), _fileBruttoFiltr, true);
Queue <decimal> _filtr_result = extPrice.FiltrBrutto(BruttoQue);
for (int i = 0; i < 5; i++)
{
decimal _sum = 0;
foreach (decimal item in _filtr_result)
{
_sum += item;
}
StaticService.LogFileWriteNotDateTime("SUMMARY_" + i + " = " + _sum.ToString(), _fileBruttoFiltr, true);
_filtr_result = extPrice.FiltrBrutto(_filtr_result);
}
/*
* // фильтруем brutto и выводим в файл
* Queue<decimal> _filtrBrut_I = extPrice.FiltrBrutto(BruttoQue);
* foreach (decimal item in _filtrBrut_I)
* {
* StaticService.LogFileWriteNotDateTime(item.ToString(), _fileBruttoFiltr, true);
* }
*
* // фильтруем _filtrBrut и выводим в файл
* StaticService.LogFileWriteNotDateTime("--------LEVEL II", _fileBruttoFiltr, true);
* Queue<decimal> _filtrBrut_II = extPrice.FiltrBrutto(_filtrBrut_I);
* foreach (decimal item in _filtrBrut_II)
* {
* StaticService.LogFileWriteNotDateTime(item.ToString(), _fileBruttoFiltr, true);
* }
*
* // summary brutto_filtr
* decimal _sum_brut_filtr = 0;
* foreach (decimal item in _filtrBrut_I)
* {
* _sum_brut_filtr += item;
* }
* StaticService.LogFileWriteNotDateTime("SUMMARY_I = " + _sum_brut_filtr.ToString(), _fileBruttoFiltr, true);
*
* _sum_brut_filtr = 0;
* foreach (decimal item in _filtrBrut_II)
* {
* _sum_brut_filtr += item;
* }
* StaticService.LogFileWriteNotDateTime("SUMMARY_II = " + _sum_brut_filtr.ToString(), _fileBruttoFiltr, true);
* //---------------------------
*/
//StaticService.LogFileWriteNotDateTime(_bruttoGlobal + " <" + _profit + ">", _filename, true);
StaticService.LogFileWriteNotDateTime(_profit + "\t" + _bruttoGlobal + "\t" + _countProfit + "\t" + _countLoss + "\t" + _countAll, _fileSummary, true);
}
