private async void buttonRun_Click(object sender, EventArgs e)
{
Stock stock = GlobalObjects.Chart.Stock;
textBoxStock.Text = stock.StockSymbol;
StockData data = await StockDataBase.Get(stock, Api.Interval.Daily);
int dataCount = data.TimeSeries.DataPoints.Count;
double simCash = 10000;
DateTime simStartDate = new DateTime(2016, 1, 1);
DateTime simEndDate = new DateTime(2017, 5, 1);
double alpha = GetStockAlphaBalance(data, simCash, simStartDate, simEndDate);
double tradeResult = 0;
IOptionTradeAlgorithm tradeAlgo = new BuyAndManageLCV();
OptionTradeList tradeList = await tradeAlgo.Find(stock, simStartDate, simEndDate);
OptionTradeSimulation sim = new OptionTradeSimulation("OptionSim", simCash, simStartDate, simEndDate, 1.1, 0.04);
sim.Run(tradeList);
GlobalObjects.Chart.Graphs.Clear();
GlobalObjects.Chart.Graphs.Add(sim.BalanceChart);
tradeResult = sim.BalanceChart.DataPoints[sim.BalanceChart.DataPoints.Count - 1].GraphData;
labelResultRightPercent.Text = tradeResult.ToString();
labelResultAlpha.Text = alpha.ToString();
}
public async Task <bool> LoadStock(Stock stock)
{
if (stock != null)
{
StockData tempData = await StockDataBase.Get(stock, Interval);
int tempDataCount = tempData.TimeSeries.DataPoints.Count;
if (tempDataCount > 0)
{
Stock prevstock = activeStock;
activeStock = stock;
activeStockData = tempData;
candleCount = tempDataCount;
DefaultRange = 100;
chartRange = DefaultRange;
if (candleCount < chartRange)
{
chartRange = candleCount;
}
DefaultRange = chartRange;
if (StockChanged != null)
{
StockChanged();
}
return(true);
}
}
return(false);
}
private async Task <bool> OpenPosition(OptionTrade trade, Api.Interval interval)
{
TimeSpan updateSpan = DateTime.UtcNow - trade.TradeDate;
StockData data = await StockDataBase.Get(trade.Spread.Stock, interval, updateSpan);
OptionPosition position = GetPosition(trade.Spread);
position.Spread = trade.Spread;
double totalBalance = await TotalBalance(trade.TradeDate, interval);
position.EntryDate = trade.TradeDate;
double margin = await trade.Spread.MaxLoss(trade.TradeDate);
double budget = totalBalance * trade.PortfolioPercentage;
if (trade.Amount == 0)
{
position.Amount = (int)(budget / (margin * (1 + Slippage) + Fee));
}
else
{
double totalCost = (margin * (1 + Slippage) + Fee) * trade.Amount;
if (Cash >= totalCost)
{
position.Amount = trade.Amount;
}
else
{
position.Amount = 0;
}
}
Cash -= position.Amount * (margin * (1 + Slippage) + Fee);
return(true);
}
public async Task <OptionTradeList> Find(Stock stock, DateTime startDate, DateTime endDate)
{
OptionTradeList tradeList = new OptionTradeList(stock, Api.Interval.Daily);
StockData data = await StockDataBase.Get(stock, Api.Interval.Daily);
int startIndex = data.FindDateIndex(startDate);
int endIndex = data.FindDateIndex(endDate);
int tradeHoldLenght = 30;
double tradeHoldMaxGain = 0.9;
double tradeHoldMaxLoss = -0.25;
double portofolioPercentage = 0.8;
bool inTrade = false;
for (int i = startIndex; i <= endIndex; i++)
{
DateTime today = data.TimeSeries.DataPoints[i].DateTime;
if (!inTrade)
{
double close = data.TimeSeries.DataPoints[i].Close;
Spread spread = Spread.GetSpread(stock, SpreadType.LongCallVertical, close - close * 0.1, 5, today.AddDays(40), today);
OptionTrade trade = new OptionTrade
{
TradeDate = data.TimeSeries.DataPoints[i].DateTime,
PortfolioPercentage = portofolioPercentage,
Spread = spread
};
tradeList.Trades.Add(trade);
inTrade = true;
}
else
{
OptionTrade lastTrade = tradeList.Trades[tradeList.Trades.Count - 1];
double openPrice = await lastTrade.Spread.Price(lastTrade.TradeDate);
double currentPrice = await lastTrade.Spread.Price(today);
double percentageGain = (currentPrice - openPrice) / openPrice;
int dateIndex = data.FindDateIndex(lastTrade.TradeDate);
if (i - dateIndex >= tradeHoldLenght || lastTrade.Spread.DaysUntilExpiration(today) < 5 || percentageGain > tradeHoldMaxGain || percentageGain < tradeHoldMaxLoss)
{
OptionTrade trade = new OptionTrade
{
TradeDate = data.TimeSeries.DataPoints[i].DateTime,
PortfolioPercentage = 0,
Spread = lastTrade.Spread
};
tradeList.Trades.Add(trade);
inTrade = false;
}
}
}
return(tradeList);
}
private async void ClosePosition(StockTrade trade, Api.Interval interval)
{
StockData data = await StockDataBase.Get(trade.Stock, interval);
StockPosition position = GetPosition(trade.Stock);
double posValue = GetPositionValue(position, data, trade.DataIndex);
position.Amount = 0;
Cash += posValue;
}
private async void ClosePosition(OptionTrade trade, Api.Interval interval)
{
TimeSpan updateSpan = DateTime.UtcNow - trade.TradeDate;
StockData data = await StockDataBase.Get(trade.Spread.Stock, interval, updateSpan);
OptionPosition position = GetPosition(trade.Spread);
double posValue = await GetPositionValue(position, data, trade.TradeDate);
Cash += posValue * (1 - Slippage) - Fee * position.Amount;
position.Amount = 0;
}
public async Task <double> Price(DateTime date)
{
double price = 0;
TimeSpan updateSpan = DateTime.UtcNow - date;
StockData data = await StockDataBase.Get(this, Api.Interval.Daily, updateSpan);
if (data != null)
{
price = data.TimeSeries.DataPoints[data.FindDateIndex(date)].Close;
}
return(price);
}
public async Task <double> TotalBalance(int dataIndex, Api.Interval interval)
{
double total = Cash;
foreach (StockPosition position in Positions)
{
StockData data = await StockDataBase.Get(position.Stock, interval);
total += GetPositionValue(position, data, dataIndex);
}
return(total);
}
public async Task <double> TotalBalance(DateTime date, Api.Interval interval)
{
double total = Cash;
foreach (OptionPosition position in Positions)
{
TimeSpan updateSpan = DateTime.UtcNow - date;
StockData data = await StockDataBase.Get(position.Spread.Stock, interval, updateSpan);
total += await GetPositionValue(position, data, date) * (1 - Slippage);
}
return(total);
}
public FormMain()
{
GlobalObjects.Initialize();
Api.Initialize(File.ReadAllText("AlphavantageKey.txt"));
StockDataBase.Initialize(TimeSpan.FromHours(5));
OptionDataBase.Initialize();
WatchListManager.Initialize();
InitializeComponent();
watchListUI.Link(GlobalObjects.Chart);
chartControl.Link(GlobalObjects.Chart);
watchListUI.LoadStockEvent += new WatchListUI.LoadStockHandler(LoadStock);
chartControl.LoadStockEvent += new ChartControl.LoadStockHandler(LoadStockChart);
}
private async void OpenPosition(StockTrade trade, Api.Interval interval)
{
StockData data = await StockDataBase.Get(trade.Stock, interval);
StockPosition position = GetPosition(trade.Stock);
double totalBalance = await TotalBalance(trade.DataIndex, interval);
position.EntryIndex = trade.DataIndex;
double entryPrice = data.TimeSeries.DataPoints[trade.DataIndex].Close;
double budget = totalBalance * trade.PortfolioPercentage;
position.Amount = (int)(budget / entryPrice);
position.Type = trade.Type;//long or short
Cash -= position.Amount * entryPrice;
}
public async void ChangeStock(Stock stock)
{
TimeSpan updateSpan = DateTime.UtcNow - _simDate;
StockData stockData = await StockDataBase.Get(stock, Api.Interval.Daily, updateSpan);
if (stockData.TimeSeries.DataPoints[0].DateTime <= _simDate)
{
_stockData = new StockData();
_stockData.MetaData = stockData.MetaData;
_dataIndex = stockData.FindDateIndex(_simDate);
if (_dataIndex <= stockData.TimeSeries.DataPoints.Count)
{
_stockData.TimeSeries.DataPoints = stockData.TimeSeries.DataPoints.GetRange(0, _dataIndex + 1);
}
}
}
public async Task <OptionTradeList> Find(Stock stock, DateTime startDate, DateTime endDate)
{
OptionTradeList tradeList = new OptionTradeList(stock, Api.Interval.Daily);
StockData data = await StockDataBase.Get(stock, Api.Interval.Daily);
int startIndex = data.FindDateIndex(startDate);
int endIndex = data.FindDateIndex(endDate);
int tradeHoldLenght = 2;
bool inTrade = false;
for (int i = startIndex; i <= endIndex; i++)
{
if (!inTrade)
{
Option[] options = new Option[2];
options[0] = new Option(stock, OptionType.Put, PositionType.Short, 230, startDate.AddDays(25));
options[1] = new Option(stock, OptionType.Put, PositionType.Long, 240, startDate.AddDays(25));
Spread spread = new Spread(options);
OptionTrade trade = new OptionTrade
{
TradeDate = data.TimeSeries.DataPoints[i].DateTime,
PortfolioPercentage = 1,
Spread = spread
};
tradeList.Trades.Add(trade);
inTrade = true;
}
else
{
OptionTrade lastTrade = tradeList.Trades[tradeList.Trades.Count - 1];
int dateIndex = data.FindDateIndex(lastTrade.TradeDate);
if (i - dateIndex >= tradeHoldLenght)
{
OptionTrade trade = new OptionTrade
{
TradeDate = data.TimeSeries.DataPoints[i].DateTime,
PortfolioPercentage = 0,
Spread = lastTrade.Spread
};
tradeList.Trades.Add(trade);
}
}
}
return(tradeList);
}
public async void NextTradeDay()
{
_dataIndex++;
TimeSpan updateSpan = DateTime.UtcNow - _simDate;
StockData stockData = await StockDataBase.Get(Stock, Api.Interval.Daily, updateSpan);
if (_dataIndex <= stockData.TimeSeries.DataPoints.Count)
{
_simDate = stockData.TimeSeries.DataPoints[_dataIndex].DateTime;
if (OptionChain.DataAvailible(Stock, _simDate))
{
ChangeStock(Stock);
_portofolioHistory.Add(new OptionPortfolio(_portfolio));
_portfolio.CloseExpiredPositions(_simDate);
NextDaySimulated?.Invoke(this, new EventArgs());
}
}
}
public async void Run(StockTradeList tradeList)
{
if (tradeList != null && tradeList.Trades.Count > 0)
{
//find all stocks traded
StockList stocks = new StockList("TradeList");
foreach (StockTrade trade in tradeList.Trades)
{
stocks.Add(trade.Stock);
}
//find DataRange
StockData firstData = await StockDataBase.Get(stocks.GetStock(0), tradeList.Interval);
int startIndex = firstData.FindDateIndex(_startDate);
int stopIndex = firstData.FindDateIndex(_endDate);
int dataCount = firstData.TimeSeries.DataPoints.Count;
if (stopIndex == 0)
{
stopIndex = dataCount - 1;
}
//Simulate trades
double startBalance = _balanceChart[0];
StockPortfolio portfolio = new StockPortfolio(startBalance);
List <double> balanceChartList = new List <double>();
balanceChartList.Add(startBalance);
for (int i = startIndex; i <= stopIndex; i++)
{
foreach (StockTrade trade in tradeList.Trades)
{
if (trade.DataIndex == i)
{
portfolio.MakeTrade(trade, tradeList.Interval);
}
}
balanceChartList.Add(await portfolio.TotalBalance(i, tradeList.Interval));
}
_balanceChart = balanceChartList.ToArray();
}
}
public async void RollBackOneDay()
{
if (_portofolioHistory.Count > 0)
{
_dataIndex--;
TimeSpan updateSpan = DateTime.UtcNow - _simDate;
StockData stockData = await StockDataBase.Get(Stock, Api.Interval.Daily, updateSpan);
if (_dataIndex >= 0)
{
_simDate = stockData.TimeSeries.DataPoints[_dataIndex].DateTime;
ChangeStock(Stock);
_portfolio = new OptionPortfolio(_portofolioHistory[_portofolioHistory.Count - 1]);
_portofolioHistory.RemoveAt(_portofolioHistory.Count - 1);
NextDaySimulated?.Invoke(this, new EventArgs());
}
}
}
public async void Load(Panel controlPanel, Panel variablePanel)
{
panelControl = controlPanel;
panelVariable = variablePanel;
string dataBasePath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\DataMAN\\Financial data\\Options\\HistoricalOptionData";
string listName = "Historical Data";
/*WatchListManager.AddNewList(listName);
* foreach (string stockFolder in Directory.GetDirectories(dataBasePath))
* {
* DirectoryInfo dInfo = new DirectoryInfo(stockFolder);
* string symbol = dInfo.Name;
* Stock stock = new Stock(symbol);
* WatchListManager.AddToList(listName, stock);
* }*/
if (MessageBox.Show("ready") == DialogResult.OK)
{
StockList list = WatchListManager.GetList("Historical Data");
foreach (string symbol in list.Stocks)
{
Stock stock = new Stock(symbol);
StockData data = await StockDataBase.Get(stock, Api.Interval.Daily, TimeSpan.FromDays(200));
DateTime lastRefeshed;
try
{
lastRefeshed = DateTime.Parse(data.MetaData.LastRefreshed);
}
catch
{
lastRefeshed = DateTime.MinValue;
}
if (DateTime.UtcNow - lastRefeshed < TimeSpan.FromMinutes(10))
{
Thread.Sleep(new TimeSpan(0, 0, 25));
}
}
MessageBox.Show("Done");
}
}
private async void buttonStart_Click(object sender, EventArgs e)
{
TrainerWindow trainer = new TrainerWindow();
DateTime startDate = dateTimePickerStart.Value;
Stock stock = new Stock(textBoxStock.Text);
if (checkBoxRandomStartDate.Checked)
{
Random r = new Random();
int totalDays = (dateTimePickerStart.MaxDate - dateTimePickerStart.MinDate).Days;
startDate = dateTimePickerStart.MinDate.AddDays(r.Next(0, totalDays - 90));
StockData data = await StockDataBase.Get(stock, Api.Interval.Daily);
startDate = data.FindClosestTradeDay(startDate);
}
if (OptionChain.DataAvailible(stock, startDate))
{
trainer.Show((double)numericUpDown1.Value, startDate, new Stock(textBoxStock.Text));
this.Close();
}
}
public async Task <double> Price(DateTime date)
{
double price = 0;
OptionChain chain = OptionDataBase.Get(_stock, date);
if (chain != null)
{
OptionChainDataPoint option = chain.FindOption(_optionType, _expDate, _strike);
price = (option.Bid + option.Ask) * 0.5;
}
else
{
TimeSpan updateSpan = DateTime.UtcNow - date;
StockData data = await StockDataBase.Get(_stock, Api.Interval.Daily, updateSpan);
int index = data.FindDateIndex(date);
int expiration = DaysUntilExpiration(date);
price = Indicators.Options.AproxPrice(data, index, _optionType, _strike, expiration);
}
return(price);
}
public async static Task <GraphData> PriceGraph(DateTime openDate, Option option)
{
StockData data = await StockDataBase.Get(option.Stock, Api.Interval.Daily);
int startIndex = data.FindDateIndex(openDate);
int endIndex = data.FindDateIndex(option.ExpirationDate);
GraphData graph = new GraphData("PriceGraph " + option.Stock.StockSymbol + " " + option.Strike.ToString() + option.OptionType.ToString());
for (int i = startIndex; i <= endIndex; i++)
{
DateTime dataPointDate = data.TimeSeries.DataPoints[i].DateTime;
Option opt = Option.GetOption(option.Stock, option.OptionType, option.PositionType, option.Strike, option.ExpirationDate, dataPointDate);
double price = await opt.Price(dataPointDate);
GraphDataPoint point = new GraphDataPoint(dataPointDate, price);
graph.DataPoints.Add(point);
}
return(graph);
}
public async void Run(OptionTradeList tradeList)
{
if (tradeList != null && tradeList.Trades.Count > 0)
{
//find DataRange
StockData firstData = await StockDataBase.Get(tradeList.Stock, tradeList.Interval);
int startIndex = firstData.FindDateIndex(_startDate);
int stopIndex = firstData.FindDateIndex(_endDate);
int dataCount = firstData.TimeSeries.DataPoints.Count;
if (stopIndex == 0)
{
stopIndex = dataCount - 1;
}
//Simulate trades
OptionPortfolio portfolio = new OptionPortfolio(_startBalance, _fee, _slippage);
_balanceChart = new GraphData(_name + " Balance");
for (int i = startIndex; i <= stopIndex; i++)
{
foreach (OptionTrade trade in tradeList.Trades)
{
int dateIndex = firstData.FindDateIndex(trade.TradeDate);
if (dateIndex == i)
{
portfolio.MakeTrade(trade, tradeList.Interval);
}
}
DateTime date = firstData.TimeSeries.DataPoints[i].DateTime;
GraphDataPoint balanceGraphDataPoint = new GraphDataPoint(date, await portfolio.TotalBalance(date, tradeList.Interval));
_balanceChart.DataPoints.Add(balanceGraphDataPoint);
}
}
}
public async Task <OptionTradeList> Find(Stock stock, DateTime startDate, DateTime endDate)
{
OptionTradeList tradeList = new OptionTradeList(stock, Api.Interval.Daily);
StockData data = await StockDataBase.Get(stock, Api.Interval.Daily);
int startIndex = data.FindDateIndex(startDate);
int endIndex = data.FindDateIndex(endDate);
int period = 40;
double priceGainGate = -0.5;
double volumeGainGate = 0.5;
int tradeHoldLenght = 15;
double tradeHoldMaxGain = 0.9;
double tradeHoldMaxLoss = -0.25;
double portofolioPercentage = 0.8;
bool inTrade = false;
for (int i = startIndex; i <= endIndex; i++)
{
if (!inTrade)
{
{
DateTime today = data.TimeSeries.DataPoints[i].DateTime;
double open = data.TimeSeries.DataPoints[i].Open;
double close = data.TimeSeries.DataPoints[i].Close;
double percentageGain = (close - open) / open;
if (percentageGain > priceGainGate)
{
double volume = data.TimeSeries.DataPoints[i].Volume;
double volumeSMA = Indicators.GetSMA(data, i, period, PricePoint.Volume);
double volumePercentageGain = (volume - volumeSMA) / volumeSMA;
if (volumePercentageGain > volumeGainGate)
{
Option[] options = new Option[2];
options[0] = new Option(stock, OptionType.Call, PositionType.Long, Math.Round(close, 0) - 5, today.AddDays(40));
options[1] = new Option(stock, OptionType.Call, PositionType.Short, Math.Round(close, 0) + 0, today.AddDays(40));
Spread spread = new Spread(options);
OptionTrade trade = new OptionTrade
{
TradeDate = data.TimeSeries.DataPoints[i].DateTime,
PortfolioPercentage = portofolioPercentage,
Spread = spread
};
tradeList.Trades.Add(trade);
inTrade = true;
}
}
}
}
else
{
OptionTrade lastTrade = tradeList.Trades[tradeList.Trades.Count - 1];
DateTime today = data.TimeSeries.DataPoints[i].DateTime;
int dateIndex = data.FindDateIndex(lastTrade.TradeDate);
double openPrice = await lastTrade.Spread.Price(lastTrade.TradeDate);
double currentPrice = await lastTrade.Spread.Price(today);
double percentageGain = (currentPrice - openPrice) / openPrice;
if (i - dateIndex >= tradeHoldLenght || lastTrade.Spread.DaysUntilExpiration(today) < 5 || percentageGain > tradeHoldMaxGain || percentageGain < tradeHoldMaxLoss)
{
OptionTrade trade = new OptionTrade
{
TradeDate = data.TimeSeries.DataPoints[i].DateTime,
PortfolioPercentage = 0,
Spread = lastTrade.Spread
};
tradeList.Trades.Add(trade);
inTrade = false;
}
}
}
return(tradeList);
}
public async Task <StockTradeList> Find(Stock stock, DateTime startDate, DateTime endDate)
{
StockTradeList tradeList = new StockTradeList(Api.Interval.Daily);
StockData data = await StockDataBase.Get(stock, Api.Interval.Daily);
int startIndex = data.FindDateIndex(startDate);
int period = 40;
double priceGainGate = -0.5;
double volumeGainGate = 0.5;
int tradeHoldLenght = 15;
double tradeHoldMaxGain = 0.04;
double tradeHoldMaxLoss = -0.04;
bool inTrade = false;
for (int i = startIndex; i < data.TimeSeries.DataPoints.Count; i++)
{
if (!inTrade)
{
{
double open = data.TimeSeries.DataPoints[i].Open;
double close = data.TimeSeries.DataPoints[i].Close;
double percentageGain = (close - open) / open;
if (percentageGain > priceGainGate)
{
double volume = data.TimeSeries.DataPoints[i].Volume;
double volumeSMA = Indicators.GetSMA(data, i, period, PricePoint.Volume);
double volumePercentageGain = (volume - volumeSMA) / volumeSMA;
if (volumePercentageGain > volumeGainGate)
{
StockTrade trade = new StockTrade
{
DataIndex = i,
PortfolioPercentage = 1,
Stock = stock,
Type = StockTradeType.LongStock
};
tradeList.Trades.Add(trade);
inTrade = true;
}
}
}
}
else
{
StockTrade lastTrade = tradeList.Trades[tradeList.Trades.Count - 1];
double posOpen = data.TimeSeries.DataPoints[lastTrade.DataIndex].Close;
double currentPrice = data.TimeSeries.DataPoints[i].Close;
double percentageGain = (currentPrice - posOpen) / posOpen;
if (i - lastTrade.DataIndex >= tradeHoldLenght)
{
StockTrade trade = new StockTrade
{
DataIndex = i,
PortfolioPercentage = 0,
Stock = stock,
Type = StockTradeType.LongStock
};
tradeList.Trades.Add(trade);
inTrade = false;
}
else if (percentageGain > tradeHoldMaxGain || percentageGain < tradeHoldMaxLoss)
{
StockTrade trade = new StockTrade
{
DataIndex = i,
PortfolioPercentage = 0,
Stock = stock,
Type = StockTradeType.LongStock
};
tradeList.Trades.Add(trade);
inTrade = false;
}
}
}
return(tradeList);
}
public async void Run(StockTradeList tradeList)
{
if (tradeList != null && tradeList.Trades.Count > 0)
{
//find all stocks traded
StockList stocks = new StockList("TradeList");
foreach (StockTrade trade in tradeList.Trades)
{
stocks.Add(trade.Stock);
}
//find DataRange
StockData firstData = await StockDataBase.Get(stocks.GetStock(0), tradeList.Interval);
int startIndex = firstData.FindDateIndex(_startDate);
int stopIndex = firstData.FindDateIndex(_endDate);
int dataCount = firstData.TimeSeries.DataPoints.Count;
if (stopIndex == 0)
{
stopIndex = dataCount - 1;
}
//Simulate trades
double timesTraded = 0;
double timesRight = 0;
StockTrade currentTrade = new StockTrade();
StockData data = firstData;
for (int i = startIndex; i <= stopIndex; i++)
{
foreach (StockTrade trade in tradeList.Trades)
{
if (trade.DataIndex == i)
{
if (trade.PortfolioPercentage > 0)
{
data = await StockDataBase.Get(trade.Stock, tradeList.Interval);
currentTrade = trade;
}
else
{
timesTraded++;
double openPrice = data.TimeSeries.DataPoints[currentTrade.DataIndex].Close;
double closePrice = data.TimeSeries.DataPoints[i].Close;
if (currentTrade.Type == StockTradeType.LongStock && closePrice > openPrice)
{
timesRight++;
}
if (currentTrade.Type == StockTradeType.ShortStock && closePrice < openPrice)
{
timesRight++;
}
}
}
}
}
//save results
_rightPredictPercentage = timesRight / timesTraded;
_tradesMade = (int)timesTraded;
}
}
