public void Calculate()
{
var fName = string.Format("{0}_{1}", typeof(T).Name, Settings.Default.ResultsFileName);
if (File.Exists(fName))
{
File.Delete(fName);
}
MemoryCache <FinamCandleProvider> cache;
using (var provider = new FinamCandleProvider(Settings.Default.InsName, Settings.Default.TimePeriod,
Settings.Default.MarketCode, Settings.Default.InsCode, Settings.Default.DateFrom, Settings.Default.DateTo))
{
cache = new MemoryCache <FinamCandleProvider>(provider);
}
File.AppendAllLines(fName, new string[] { "Parameters;Populations total;Sharp Index;Profit;Mean profit per deal;Mean +profit per deal;Mean -profit per deal;Success %;" });
for (var i = Settings.Default.ParamsCountFrom; i < Settings.Default.ParamsCountTo; i = i + 2)
{
_num = i;
Console.Title = string.Format("Length {0}", _num);
Console.WriteLine();
Console.WriteLine(" Length {0}:", i);
Console.WriteLine(" ----------------------------------------------------------------");
Console.WriteLine(" | iter | profit | sharp | mean p | success | mean p+ | mean p- |");
Console.WriteLine(" ----------------------------------------------------------------");
var genSelector = new GeneticsSelector <FinamCandleProvider, T>(cache, 3, 100, i, generationSize: Settings.Default.GenerationSize, threadsNum: Settings.Default.ThreadsCount, crossPercent: Settings.Default.CrossPercent);
genSelector.PopulationCompleted += GenSelector_PopulationCompleted;
genSelector.Select(Settings.Default.PopulationsCount);
genSelector.Wait();
var result = genSelector.GetBestResults().First();
File.AppendAllLines(fName,
new string[]
{
string.Format("{0};{1};{2};{3};{4};{5};{6};{7};",
string.Join(",", result.Parameters),
genSelector.PopulationIndex,
result.SharpIndex,
result.Balance,
result.MeanProfit,
result.MeanPositiveProfit,
result.MeanNegativeProfit,
result.SuccessRatio)
});
// generate result file for best result
var algDataFileName = string.Format("{0}_{1}params_{2}",
typeof(T).Name, i, Settings.Default.ResultsFileName);
AlgDataExport.ExportToCSV(result, algDataFileName, typeof(T).Name);
}
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Calculation completed.");
Console.ReadLine();
_num = 0;
}
public void TestFinamProviderBasicDownload()
{
var lowDate = new DateTime(2016, 6, 10);
var highDate = new DateTime(2016, 7, 10);
using (var provider = new FinamCandleProvider("SPFB.SI", TimePeriod.Hour,
"14", "19899", lowDate, highDate))
{
Assert.AreEqual(provider.Current, default(Candle));
provider.Initialize();
var num = 0;
while (provider.MoveNext())
{
num++;
Assert.IsTrue(provider.Current.TimeStamp >= lowDate && provider.Current.TimeStamp <= highDate);
}
Assert.AreEqual(279, num);
}
}
public void TestGuppiAlgMatrix()
{
var alg = new GuppiAlgorithm(4, 6, 9, 11, 13, 16, 31, 36, 41, 46, 51, 61);
using (var provider = new FinamCandleProvider("SPFB.SI", TimePeriod.Hour,
"14", "19899", new DateTime(2013, 9, 1), new DateTime(2014, 03, 10)))
{
provider.Initialize();
using (var reader = new StreamReader(@"data\guppi_data.dat"))
{
var startDate = new DateTime(2014, 01, 13, 15, 0, 0);
while (provider.Current.TimeStamp != startDate)
{
provider.MoveNext();
alg.Check(provider.Current);
}
reader.ReadLine();
while (!reader.EndOfStream)
{
provider.MoveNext();
alg.Check(provider.Current);
var data = reader.ReadLine().Split(';');
var algData = alg.Data.Last();
int i;
for (i = 0; i < 12; i++)
{
Assert.IsTrue(Math.Abs(float.Parse(data[i]) - algData[i]) <= 1);
}
for (i = 12; i < 24; i++)
{
Assert.AreEqual(int.Parse(data[i]), algData[i]);
}
Assert.IsTrue(algData[33] == algData[28] && algData[28] == -1);
}
}
}
}
static void Main(string[] args)
{
List <Type> algTypes = new List <Type>();
var searchPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
foreach (var file in Directory.GetFiles(searchPath, "*.dll"))
{
algTypes.AddRange(Assembly.LoadFrom(file).GetTypes()
.Where(o =>
o.BaseType == typeof(AlgorithmBase) &&
o.IsDefined(typeof(AlgorithmAttribute))));
}
Console.WriteLine("=== Found {0} algorithms ===", algTypes.Count());
for (var i = 1; i <= algTypes.Count(); i++)
{
Console.WriteLine(" {0}) {1}", i, algTypes[i - 1].Name);
}
Console.WriteLine();
Console.Write(" Select algorithm: ");
int num;
int.TryParse(Console.ReadLine(), out num);
if (num < 1 || num > algTypes.Count())
{
Console.WriteLine("Incorrect choice.");
Console.ReadLine();
return;
}
if (!args.Any() || (args[0] == "--genetics"))
{
var calc = (IRealTimeCalculator)Activator.CreateInstance(typeof(RealTimeCalculator <>)
.MakeGenericType(algTypes[num - 1]));
calc.Calculate();
}
if (args[0] == "--calculate")
{
if (args.Length <= 1)
{
return;
}
using (var provider = new FinamCandleProvider(Settings.Default.InsName, Settings.Default.TimePeriod,
Settings.Default.MarketCode, Settings.Default.InsCode, Settings.Default.DateFrom, Settings.Default.DateTo))
{
var calc = (ICalculator <FinamCandleProvider>)Activator.CreateInstance(typeof(Calculator <,>)
.MakeGenericType(typeof(FinamCandleProvider), algTypes[num - 1]));
calc.MemCache = new MemoryCache <FinamCandleProvider>(provider);
foreach (var arg in args.Skip(1))
{
if (!arg.StartsWith("--p="))
{
return;
}
var splits = arg.Split('=').Last().Split(',');
var prms = new float[splits.Length];
for (var i = 0; i < splits.Length; i++)
{
float p;
if (!float.TryParse(splits[i], out p))
{
return;
}
prms[i] = p;
}
calc.AddParamsForCalculation(prms);
}
calc.CalculateAsync();
calc.Wait();
var n = 0;
foreach (var r in calc.Results)
{
n++;
AlgDataExport.ExportToCSV(r, string.Format("{0}_{1}",
n, Settings.Default.ResultsFileName), algTypes[num - 1].Name);
}
}
}
}
