private void optimizeInternally(List <string> indicatorsToTry, IndicatorSelector selector)
{
while (ended == false)
{
try
{
//generator.getGeneratedIndicator(Convert.ToInt32(outcomeTimeframe / 1000 / 15), Convert.ToInt32(outcomeTimeframe * 100 / 1000));
int index = getNextIndex();
if (index >= indicatorsToTry.Count)
{
break;
}
WalkerIndicator wi = IndicatorGenerator.getIndicatorByString(indicatorsToTry[index]);
LearningIndicator li = new LearningIndicator(wi, priceData, outcomeCodeData, outcomeData, outcomeTimeframe, outcomeCodePercent, minPercentThreshold, learningIndicatorSteps, true);
selector.pushIndicatorStatistics(li);
}
catch (TooLittleValidDataException e)
{
//Logger.log("E:" + e.Message);
}
catch (TooLittleStatesException e)
{
//Logger.log("E:" + e.Message);
}
catch (Exception e)
{
Logger.log("FATAL:" + e.Message);
}
}
ended = true;
}
public static double[] getIndicatorValues(double[][] priceData, WalkerIndicator indicator, out double indicatorValidRatio)
{
indicatorValidRatio = 0;
double[] output = new double[priceData.Length];
for (int i = 0; i < priceData.Length; i++)
{
long timestamp = Convert.ToInt64(priceData[i][(int)PriceDataIndeces.Date]);
double mid = (priceData[i][(int)PriceDataIndeces.Ask] + priceData[i][(int)PriceDataIndeces.Bid]) / 2d;
double value = indicator.setNextDataAndGetIndicator(timestamp, mid);
if (double.IsNaN(value) == false && double.IsInfinity(value) == false && indicator.isValid(timestamp))
{
output[i] = value;
indicatorValidRatio++;
}
else
{
output[i] = double.NaN;
}
}
indicatorValidRatio /= output.Length;
return(output);
}
void IDataminingDatabase.addIndicator(WalkerIndicator indicator, string instrument, string fieldId)
{
var collection = mongodb.getDB().GetCollection("prices");
long start = database.getFirstTimestamp();
long end = database.getLastTimestamp();
string name = "Indicator " + indicator.getName() + " " + instrument + " " + fieldId;
progress.setProgress(name, 0);
int done = 0;
long count = 0;
var docs = collection.FindAs <BsonDocument>(Query.And(Query.Exists(fieldId), Query.EQ("instrument", instrument), Query.LT("timestamp", end), Query.GTE("timestamp", start))).SetSortOrder(SortBy.Ascending("timestamp"));
docs.SetFlags(QueryFlags.NoCursorTimeout);
count = docs.Count();
foreach (var doc in docs)
{
progress.setProgress(name, Convert.ToInt32(Convert.ToDouble(done) / Convert.ToDouble(count) * 100d));
done++;
indicator.setNextData(doc["timestamp"].AsInt64, doc[fieldId].AsDouble);
collection.FindAndModify(new FindAndModifyArgs()
{
Query = Query.EQ("_id", doc["_id"]),
Update = Update.Set(indicator.getName() + "_" + fieldId, indicator.getIndicator().value)
});
}
progress.remove(name);
}
public WalkerIndicator getGeneratedIndicator(int minTimeFrameSeconds, int maxTimeframeSeconds)
{
while (true)
{
WalkerIndicator theIndicator = getRandomIndicator(minTimeFrameSeconds, maxTimeframeSeconds);
if (doneIndicators.ContainsKey(theIndicator.getName()) == false)
{
try {
doneIndicators.Add(theIndicator.getName(), true);
}
catch (Exception e) { Logger.log("#######: " + e.Message); }
return(theIndicator);
}
}
}
private void testAndSubmitResult(WalkerIndicator indicator)
{
Logger.log("Testing Indicator: " + indicator.getName());
LearningIndicator li = new LearningIndicator(indicator, priceData, outcomeCodeData, outcomeData, outcomeTimeframe, outcomeCodePercent, 0.5, learningIndicatorSteps, true);
double[] pp = li.getPredictivePowerArray();
//Results
string output = "";
foreach (double d in pp)
{
output += d + ";";
}
output += li.getUsedValues() + ";";
output += indicator.getName().Split('_')[0] + ";" + indicator.getName();
Logger.log("Result: " + li.getName());
state = li.getName();
submitResults(output);
}
private void maxPpOutcomeCodeBtn_Click(object sender, EventArgs e)
{
DataminingInputDialog id = new DataminingInputDialog(new string[] { "instrument", "outcomeCodeId" }, dataminingDb.getInfo());
id.ShowDialog();
long operationSum = 0;
int operationsCount = 0;
if (id.isValidResult())
{
string instrument = id.getResult()["instrument"];
string outcomeId = id.getResult()["outcomeCodeId"];
string folderPath = Config.startupPath + "/analysis/";
if (Directory.Exists(folderPath) == false)
{
Directory.CreateDirectory(folderPath);
}
string graphFolderPath = folderPath + "ppForIndicators-" + outcomeId + "/";
Directory.CreateDirectory(graphFolderPath);
string indicatorListFilename = folderPath + "ppForIndicators-" + outcomeId + ".csv";
if (File.Exists(indicatorListFilename) == false)
{
writeTextToFile(indicatorListFilename, "OverHalf;MaxDiff;Direction;LinRegr;LogRegr;Indicator" + Environment.NewLine);
}
//Start some threads for
for (int threadId = 0; threadId < 2; threadId++) //Todo: Do 4 threads
{
new Thread(delegate()
{
while (true)
{
try
{
Stopwatch watch = new Stopwatch();
watch.Start();
WalkerIndicator indicator = IndicatorGenerator.getRandomIndicator();
string indicatorId = "mid-" + indicator.getName();
Logger.log("Start indicator: " + indicatorId, "maxPp");
setState("Max pp: avg" + Math.Round(operationSum / 1000d / (operationsCount != 0 ? operationsCount : 1)) + "s" + " n" + operationsCount);
try {
dataminingDb.addIndicator(indicator, instrument, "mid");
} catch (IndicatorNeverValidException)
{
writeTextToFile(indicatorListFilename, "x;x;x;" + indicatorId + Environment.NewLine);
Logger.log("Invalid Indicator " + indicatorId, "maxPp");
continue;
}
Logger.log("Get info", "maxPp");
DistributionRange range = dataminingDb.getInfo(indicatorId).ranges["5"];
SampleOutcomeCodeExcelGenerator excel = new SampleOutcomeCodeExcelGenerator(graphFolderPath + indicatorId + ".xls");
Logger.log("Start sampling", "maxPp");
double[] ppMethod1 = dataminingDb.getOutcomeCodeIndicatorSampling(excel, indicatorId, 20, range, outcomeId, instrument);
excel.FinishDoc();
/*double[][] inputsTraining = new double[0][], outputsTraining = new double[0][];
* dataminingDb.getInputOutputArrays(new string[] { indicatorId }, outcomeId, instrument, ref inputsTraining, ref outputsTraining, DataGroup.All, 1000 * 20, 0);
*
* double[][] inputsTest = new double[0][], outputsTest = new double[0][];
* dataminingDb.getInputOutputArrays(new string[] { indicatorId }, outcomeId, instrument, ref inputsTest, ref outputsTest, DataGroup.All, 5000, 1);
*
* double ppMethod2 = PredictivePowerAnalyzer.getPredictivePowerWithMl(inputsTraining, outputsTraining, inputsTest, outputsTest, MLMethodForPPAnalysis.LinearRegression);
*
* double ppMethod3 = PredictivePowerAnalyzer.getPredictivePowerWithMl(inputsTraining, outputsTraining, inputsTest, outputsTest, MLMethodForPPAnalysis.LogRegression);*/
Logger.log("write to file", "maxPp");
//over 0.5, maxDiff, direction
string resultLine = ppMethod1[0] + ";" + ppMethod1[1] + ";" + ppMethod1[2] + ";" + "ni" + ";" + "ni" + ";" + indicatorId;
writeTextToFile(indicatorListFilename, resultLine + Environment.NewLine);
Logger.sendImportantMessage(DateTime.Now.ToShortTimeString() + " - " + resultLine);
Logger.log("remove datasets", "maxPp");
dataminingDb.removeDataset(indicatorId, instrument);
watch.Stop();
operationSum += watch.ElapsedMilliseconds;
operationsCount++;
}
catch {
Logger.log("Error in thread method", "maxPp");
}
}
}).Start();
}
}
}
public LearningIndicator(WalkerIndicator indicator, double[][] prices, bool[][] outcomeCodes, double[][] outcomes, long timeframe, double targetPercent, double minPercentThreshold, int steps, bool createStatistics)
{
this.targetPercent = targetPercent;
this.timeframe = timeframe;
double validRatio;
double[] values = IndicatorRunner.getIndicatorValues(prices, indicator.Clone(), out validRatio);
if (validRatio < 0.5)
{
throw new TooLittleValidDataException("Not enough valid values: " + validRatio);
}
//May be does not work properly... todo:
double min, max, usedValuesRatio;
//DistributionHelper.getMinMax(values, 4, out min, out max);
DistributionHelper.getMinMax(values, out min, out max);
outcomeCodeSamplingTable = IndicatorSampler.sampleValuesOutcomeCode(values, outcomeCodes, min, max, steps, out usedValuesRatio);
if (usedValuesRatio < 0.5)
{
throw new TooLittleValidDataException("Not enough sampling for outcomeCode: " + usedValuesRatio);
}
outcomeSamplingTable = IndicatorSampler.sampleValuesOutcome(values, prices, outcomes, min, max, out usedValuesRatio, 40);
if (usedValuesRatio < 0.5)
{
throw new TooLittleValidDataException("Not enough sampling for outcome: " + usedValuesRatio);
}
this.usedValues = usedValuesRatio;
if (createStatistics)
{
//Predictive power calculation
predictivePower = new double[33];
IndicatorSampler.getStatisticsOutcomeCodes(values, outcomeCodes, out predictivePower[0], out predictivePower[1], out predictivePower[2], out predictivePower[3]);
IndicatorSampler.getStatisticsOutcomes(values, prices, outcomes, out predictivePower[4], out predictivePower[5], out predictivePower[6], out predictivePower[7], out predictivePower[8], out predictivePower[9]);
DistributionHelper.getSampleOutcomeCodesBuyMaxSellMax(outcomeCodeSamplingTable, minPercentThreshold, out predictivePower[10], out predictivePower[11], out predictivePower[12], out predictivePower[13]);
DistributionHelper.getSampleOutcomesMinMax(outcomeSamplingTable, minPercentThreshold, out predictivePower[14], out predictivePower[15], out predictivePower[16], out predictivePower[17], out predictivePower[18], out predictivePower[19], out predictivePower[20], out predictivePower[21], out predictivePower[22], out predictivePower[23]);
//Outcome Code
List <double> buyCodesDist = new List <double>(),
sellCodesDist = new List <double>(),
buySellDistanceDist = new List <double>(),
minMaxDistanceDist = new List <double>(),
minDist = new List <double>(),
maxDist = new List <double>(),
actualDist = new List <double>();
double totalCodeSamples = 0;
foreach (double[] row in outcomeCodeSamplingTable)
{
totalCodeSamples += row[(int)SampleValuesOutcomeCodesIndices.SamplesCount];
}
int regardedStates = 0;
foreach (double[] row in outcomeCodeSamplingTable)
{
if ((row[(int)SampleValuesOutcomeCodesIndices.SamplesCount] / totalCodeSamples) * 100 >= minPercentThreshold) //minPercentThreshold
{
buyCodesDist.Add(row[(int)SampleValuesOutcomeCodesIndices.BuyRatio]);
sellCodesDist.Add(row[(int)SampleValuesOutcomeCodesIndices.SellRatio]);
buySellDistanceDist.Add(Math.Abs(row[(int)SampleValuesOutcomeCodesIndices.BuyRatio] - row[(int)SampleValuesOutcomeCodesIndices.SellRatio]));
regardedStates++;
}
}
predictivePower[(int)LearningIndicatorPredictivePowerIndecies.valuesOverMinPercentRatioCode] = Convert.ToDouble(regardedStates) / outcomeCodeSamplingTable.Length;
if (regardedStates <= 2)
{
throw new TooLittleStatesException("Too little sates: " + regardedStates);
}
predictivePower[(int)LearningIndicatorPredictivePowerIndecies.buyCodeStD] = buyCodesDist.StandardDeviation();
predictivePower[(int)LearningIndicatorPredictivePowerIndecies.sellCodeStD] = sellCodesDist.StandardDeviation();
predictivePower[(int)LearningIndicatorPredictivePowerIndecies.buySellCodeDistanceStD] = buySellDistanceDist.StandardDeviation();
//Outcome
double totalSamples = 0;
foreach (double[] row in outcomeSamplingTable)
{
totalSamples += row[(int)SampleValuesOutcomeIndices.SamplesCount];
}
//Avgs
regardedStates = 0;
foreach (double[] row in outcomeSamplingTable)
{
if ((row[(int)SampleValuesOutcomeIndices.SamplesCount] / totalSamples) * 100 > minPercentThreshold) //minPercentThreshold
{
maxDist.Add(row[(int)SampleValuesOutcomeIndices.MaxAvg]);
minDist.Add(row[(int)SampleValuesOutcomeIndices.MinAvg]);
minMaxDistanceDist.Add(Math.Abs(row[(int)SampleValuesOutcomeIndices.MaxAvg]) + row[(int)SampleValuesOutcomeIndices.MinAvg]);
actualDist.Add(row[(int)SampleValuesOutcomeIndices.ActualAvg]);
regardedStates++;
}
}
predictivePower[(int)LearningIndicatorPredictivePowerIndecies.valuesOverMinPercentRatioOutcome] += Convert.ToDouble(regardedStates) / outcomeSamplingTable.Length;
//avg distances
predictivePower[(int)LearningIndicatorPredictivePowerIndecies.maxStD] = maxDist.StandardDeviation();
predictivePower[(int)LearningIndicatorPredictivePowerIndecies.minStD] = minDist.StandardDeviation();
predictivePower[(int)LearningIndicatorPredictivePowerIndecies.minMaxDistanceStd] = minMaxDistanceDist.StandardDeviation();
predictivePower[(int)LearningIndicatorPredictivePowerIndecies.actualStD] = actualDist.StandardDeviation();
if (double.IsNaN(predictivePower[(int)LearningIndicatorPredictivePowerIndecies.buyCodeStD]) ||
double.IsNaN(predictivePower[(int)LearningIndicatorPredictivePowerIndecies.sellCodeStD]) ||
double.IsNaN(predictivePower[(int)LearningIndicatorPredictivePowerIndecies.buySellCodeDistanceStD]) ||
double.IsNaN(predictivePower[(int)LearningIndicatorPredictivePowerIndecies.maxStD]) ||
double.IsNaN(predictivePower[(int)LearningIndicatorPredictivePowerIndecies.minStD]) ||
double.IsNaN(predictivePower[(int)LearningIndicatorPredictivePowerIndecies.minMaxDistanceStd]) ||
double.IsNaN(predictivePower[(int)LearningIndicatorPredictivePowerIndecies.actualStD]))
{
throw new Exception("Not a valid predictive power!");
}
//End predictive power calculation
}
this.indicator = indicator;
}
public static WalkerIndicator getRandomIndicator()
{
WalkerIndicator theIndicator = null;
long timeframeOne = z.Next(1, 2880) * 60 * 1000;
long timeframeTwo = z.Next(1, 2880) * 60 * 1000;
long timeFrameThree = z.Next(1, 2880) * 60 * 1000;
long timeFrameSmaller = z.Next(1, 2880) * 60 * 1000;
switch (z.Next(0, 18)) //Todo: set max value for choosing the indicator
{
case 0:
theIndicator = new BolingerBandsIndicator(timeframeOne, getRanDouble(1d, 5d));
break;
case 1:
theIndicator = new MACDContinousIndicator(timeframeOne, timeframeTwo, timeFrameSmaller);
break;
case 2:
theIndicator = new MACDIndicator(timeframeOne, timeframeTwo, timeFrameSmaller);
break;
case 3:
theIndicator = new MovingAveragePriceSubtractionIndicator(timeframeOne);
break;
case 4:
theIndicator = new MovingAverageSubtractionCrossoverIndicator(timeframeOne, timeframeTwo);
break;
case 5:
theIndicator = new MovingAverageSubtractionIndicator(timeframeOne, timeframeTwo);
break;
case 6:
theIndicator = new RangeIndicator(timeframeOne);
break;
case 7:
theIndicator = new RSIBorderCrossoverIndicator(timeframeOne, getRanDouble(0.1, 0.4));
break;
case 8:
theIndicator = new RSIBorderIndicator(timeframeOne, getRanDouble(0.1, 0.4));
break;
case 9:
theIndicator = new RSIIndicator(timeframeOne);
break;
case 10:
theIndicator = new RSIMACrossoverContinousIndicator(timeframeOne, timeFrameSmaller);
break;
case 11:
theIndicator = new RSIMACrossoverIndicator(timeframeOne, timeFrameSmaller);
break;
case 12:
theIndicator = new StandartDeviationIndicator(timeframeOne);
break;
case 13:
theIndicator = new StochBorderCrossoverIndicator(timeframeOne, getRanDouble(0.1, 0.4));
break;
case 14:
theIndicator = new StochBorderIndicator(timeframeOne, getRanDouble(0.1, 0.4));
break;
case 15:
theIndicator = new StochIndicator(timeframeOne);
break;
case 16:
theIndicator = new VolumeAtPriceIndicator(timeframeOne, getRanDouble(0.0003, 0.002), z.Next(1000 * 30, 1000 * 60 * 10));
break; //Not sure about stepsize todo
case 17:
theIndicator = new TimeOfDayIndicator(); //Only once?
break;
case 18:
theIndicator = new TimeDayOfWeekIndicator(); //Todo: Only once?
break;
default:
throw new Exception("Fired a unexpected random value");
}
return(theIndicator);
}
public static WalkerIndicator getIndicatorByString(string input)
{
string[] args;
if (input.Contains("_") == false)
{
args = new string[] { input }
}
;
else
{
args = input.Split('_');
}
WalkerIndicator selected = null;
if (args[0] == BolingerBandsIndicator.Name)
{
selected = new BolingerBandsIndicator(long.Parse(args[1]), double.Parse(args[2]));
}
if (args[0] == MACDContinousIndicator.Name)
{
selected = new MACDContinousIndicator(long.Parse(args[1]), long.Parse(args[2]), long.Parse(args[3]));
}
if (args[0] == MACDIndicator.Name)
{
selected = new MACDIndicator(long.Parse(args[1]), long.Parse(args[2]), long.Parse(args[3]));
}
if (args[0] == MovingAverageIndicator.Name)
{
selected = new MovingAverageIndicator(long.Parse(args[1]));
}
if (args[0] == MovingAveragePriceSubtractionIndicator.Name)
{
selected = new MovingAveragePriceSubtractionIndicator(long.Parse(args[1]));
}
if (args[0] == MovingAverageSubtractionIndicator.Name)
{
selected = new MovingAverageSubtractionIndicator(long.Parse(args[1]), long.Parse(args[2]));
}
if (args[0] == MovingAverageSubtractionCrossoverIndicator.Name)
{
selected = new MovingAverageSubtractionCrossoverIndicator(long.Parse(args[1]), long.Parse(args[2]));
}
if (args[0] == RangeIndicator.Name)
{
selected = new RangeIndicator(long.Parse(args[1]));
}
if (args[0] == RSIBorderCrossoverIndicator.Name)
{
selected = new RSIBorderCrossoverIndicator(long.Parse(args[1]), double.Parse(args[2]));
}
if (args[0] == RSIBorderIndicator.Name)
{
selected = new RSIBorderIndicator(long.Parse(args[1]), double.Parse(args[2]));
}
if (args[0] == RSIIndicator.Name)
{
selected = new RSIIndicator(long.Parse(args[1]));
}
if (args[0] == RSIMACrossoverContinousIndicator.Name)
{
selected = new RSIMACrossoverContinousIndicator(long.Parse(args[1]), long.Parse(args[2]));
}
if (args[0] == RSIMACrossoverIndicator.Name)
{
selected = new RSIMACrossoverIndicator(long.Parse(args[1]), long.Parse(args[2]));
}
if (args[0] == StandartDeviationIndicator.Name)
{
selected = new StandartDeviationIndicator(long.Parse(args[1]));
}
if (args[0] == StochBorderCrossoverIndicator.Name)
{
selected = new StochBorderCrossoverIndicator(long.Parse(args[1]), double.Parse(args[2]));
}
if (args[0] == StochBorderIndicator.Name)
{
selected = new StochBorderIndicator(long.Parse(args[1]), double.Parse(args[2]));
}
if (args[0] == StochIndicator.Name)
{
selected = new StochIndicator(long.Parse(args[1]));
}
if (args[0] == TestIndicator.Name)
{
selected = new TestIndicator();
}
if (args[0] == TimeDayOfWeekIndicator.Name)
{
selected = new TimeDayOfWeekIndicator();
}
if (args[0] == TimeOfDayIndicator.Name)
{
selected = new TimeOfDayIndicator();
}
if (args[0] == TimeOpeningHoursIndicator.Name)
{
selected = new TimeOpeningHoursIndicator();
}
if (args[0] == VolumeAtPriceIndicator.Name)
{
selected = new VolumeAtPriceIndicator(long.Parse(args[1]), double.Parse(args[2]), long.Parse(args[3]));
}
if (selected == null)
{
throw new Exception("Name not found: " + args[0]);
}
if (selected.getName() != input)
{
throw new Exception(input + " != " + selected.getName());
}
return(selected);
}
public void updateIndicators(long timeframeToLookBack, long timeframeToLookBackForIndicatorInit, IndicatorSelector indicatorSelector)
{
List <double[]> selectedPriceData = new List <double[]>();
for (int i = priceData.Count - 1; i > 0; i--)
{
if (Convert.ToInt64(priceData[i][(int)PriceDataIndeces.Date]) > timestampNow - timeframeToLookBack)
{
selectedPriceData.Insert(0, priceData[i]); //Todo: List direction correct?
}
else
{
break;
}
}
double[][] selectedPriceDataArray = selectedPriceData.ToArray();
double s;
double[][] outcomeData = OutcomeGenerator.getOutcome(selectedPriceDataArray, outcomeTimeframe, out s);
if (s < 0.6)
{
throw new Exception("s < o.6: " + s);
}
//bool[][] outcomeCodeData = OutcomeGenerator.getOutcomeCode(selectedPriceDataArray, outcomeData, outcomeCodePercent, out s);
bool[][] outcomeCodeFirstData = OutcomeGenerator.getOutcomeCodeFirst(selectedPriceDataArray, outcomeTimeframe, outcomeCodePercent, out s);
if (s < 0.6)
{
throw new Exception("s < o.6: " + s);
}
string[] indicatorIds;
//This part can be skipped by caching todo: get from outside
double hash = outcomeTimeframe + selectedPriceData[0].Sum() + selectedPriceData[selectedPriceData.Count - 1].Sum() + selectedPriceData[selectedPriceData.Count / 2].Sum();
string optimalIndicatorsFileName = cachePath + "/" + "optimalIndicatorsIn_" + hash + "_" + selectedPriceData[selectedPriceData.Count - 1][(int)PriceDataIndeces.Date] + "_" + timeframeToLookBack + "_" + outcomeCodePercent + ".txt";
if (cachePath != null && File.Exists(optimalIndicatorsFileName))
{
indicatorIds = File.ReadAllText(optimalIndicatorsFileName).Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
Logger.log("Loaded optimal indicators from file: " + optimalIndicatorsFileName);
}
else
{
//Shuffle okay indicators? todo:
Logger.log("Generated optimal indicators");
IndicatorOptimizer optimizer = new IndicatorOptimizer(selectedPriceDataArray, outcomeData, outcomeCodeFirstData, outcomeTimeframe, outcomeCodePercent, minPercentThreshold, learningIndicatorSteps);
indicatorIds = optimizer.getOptimizedIndicators(okayIndicators, indicatorSelector, 8);
File.WriteAllLines(optimalIndicatorsFileName, indicatorIds);
}
Logger.log("Selected indicators: ");
List <LearningIndicator> lis = new List <LearningIndicator>();
foreach (string str in indicatorIds)
{
Logger.log(str);
WalkerIndicator ind = IndicatorGenerator.getIndicatorByString(str);
if (ind.getName() != str)
{
throw new Exception(str + "!=" + ind.getName());
}
lis.Add(new LearningIndicator(ind, selectedPriceDataArray, outcomeCodeFirstData, outcomeData, outcomeTimeframe, outcomeCodePercent, minPercentThreshold, learningIndicatorSteps, false));
}
SignalMachine sm = new AlternativeSignalMachine(lis.ToArray()); //Todo: make accessable copy?
Logger.log("SM STATE: ##################" + Environment.NewLine + sm.getStateMessage());
//Make them up to date
List <double[]> selectedPriceDataForIndicatorInit = new List <double[]>();
for (int i = priceData.Count - 1; i > 0; i--)
{
if (Convert.ToInt64(priceData[i][(int)PriceDataIndeces.Date]) > timestampNow - timeframeToLookBackForIndicatorInit)
{
selectedPriceDataForIndicatorInit.Insert(0, priceData[i]); //Todo: List direction correct?
}
else
{
break;
}
}
foreach (double[] row in selectedPriceDataForIndicatorInit)
{
sm.pushPrice(row);
}
this.signalMachine = sm;
}
private void FindOkayIndicatorsForm_Load(object sender, EventArgs e)
{
timer1.Start();
string okayIndicatorsFile = "okayIndicators" + outcomeTimeframe + ".txt";
if (File.Exists(okayIndicatorsFile))
{
List <string> lines = File.ReadLines(okayIndicatorsFile).ToList();
foreach (string line in lines)
{
if (line != "" && line != null && line != " ")
{
found.Add(line, true);
}
}
}
DataLoader dl = new DataLoader(Config.DataPath + pair);
double[][] priceData = dl.getArray(1000 * 60 * 60 * 24 * 30l,
timeframeToTest,
minTimestep); //One month, but the second. Every 10 secs
double success;
bool[][] outcomeCodeFirstData = OutcomeGenerator.getOutcomeCodeFirst(priceData, outcomeTimeframe, outcomeCodePercent, out success);
if (success < 0.7)
{
throw new Exception("OutcomeCode low success: " + success);
}
double[][] outcomeData = OutcomeGenerator.getOutcome(priceData, outcomeTimeframe, out success);
if (success < 0.7)
{
throw new Exception("Outcome low success: " + success);
}
IndicatorGenerator generator = new IndicatorGenerator();
new Thread(delegate() {
while (true)
{
WalkerIndicator ind = generator.getGeneratedIndicator(Convert.ToInt32((outcomeTimeframe / 1000) / 10), Convert.ToInt32((outcomeTimeframe / 1000) * 100));
try
{
if (found.ContainsKey(ind.getName()) == false)
{
tried++;
new LearningIndicator(ind, priceData, outcomeCodeFirstData, outcomeData, outcomeTimeframe, outcomeCodePercent, minPercentThreshold, learningIndicatorSteps, false);
File.AppendAllText(okayIndicatorsFile, ind.getName() + Environment.NewLine);
found.Add(ind.getName(), true);
}
}
catch (Exception) { }
}
}).Start();
}
public FakeTradingAPI()
{
tradingTime = new TimeOpeningHoursIndicator();
}
