public void Throws() { var time = DateTimeOffset.FromUnixTimeMilliseconds(DateTime.UtcNow.ToTimestamp()).UtcDateTime; const long firstTradeId = 1234567890; const long lastTradeId = 1234567899; const bool isFinal = true; var symbol = Symbol.BTC_USDT; const CandlestickInterval interval = CandlestickInterval.Hour; var openTime = DateTimeOffset.FromUnixTimeMilliseconds(DateTime.UtcNow.ToTimestamp()).UtcDateTime; const decimal open = 4950; const decimal high = 5100; const decimal low = 4900; const decimal close = 5050; const decimal volume = 1000; var closeTime = openTime.AddHours(1); const long quoteAssetVolume = 5000000; const int numberOfTrades = 555555; const decimal takerBuyBaseAssetVolume = 4444; const decimal takerBuyQuoteAssetVolume = 333; var candlestick = new Candlestick(symbol, interval, openTime, open, high, low, close, volume, closeTime, quoteAssetVolume, numberOfTrades, takerBuyBaseAssetVolume, takerBuyQuoteAssetVolume); Assert.Throws <ArgumentNullException>("candlestick", () => new CandlestickEventArgs(time, null, firstTradeId, lastTradeId, isFinal)); Assert.Throws <ArgumentException>("firstTradeId", () => new CandlestickEventArgs(time, candlestick, -2, lastTradeId, isFinal)); Assert.Throws <ArgumentException>("lastTradeId", () => new CandlestickEventArgs(time, candlestick, firstTradeId, -2, isFinal)); Assert.Throws <ArgumentException>("lastTradeId", () => new CandlestickEventArgs(time, candlestick, firstTradeId, firstTradeId - 1, isFinal)); }
public override void Calculate(int index) { //Print("LastCandlestick: {0} at index: {1}", this.GetMarketSeries(index), index); cs1 = this.GetMarketSeries(index); cs2 = this.GetMarketSeries(index - 1); cs3 = this.GetMarketSeries(index - 2); // Calculate value at specified index // Result[index] = ... if ( cs2.Height.IsPositive() && cs3.Height.IsPositive() && cs2.Height / cs3.Height >= TriggerHeightRatio && cs2.High < cs3.High && cs2.Low < cs3.Low && cs2.CloseToLowHeight / cs3.CloseToLowHeight >= TriggerHLRatio ) { BuySignal[index - 1] = cs2.RealBodyLow; SellSignal[index] = this.ShiftPrice(cs1.Open, TargetPoints); } if ( cs2.Height.IsPositive() && cs3.Height.IsPositive() && cs2.Height / cs3.Height >= TriggerHeightRatio && cs2.High > cs3.High && cs2.Low > cs3.Low && cs2.HighToCloseHeight / cs3.HighToCloseHeight >= TriggerHLRatio ) { SellSignal[index - 1] = cs2.RealBodyHigh; BuySignal[index] = this.ShiftPrice(cs1.Open, -TargetPoints); } }
public void AddCandleStick(Candlestick futureCandleStick) { var list = new List <Candlestick>(); list.Add(futureCandleStick); list.AddRange(_candleSticks.Take(100)); _candleSticks = list; rsi.AddCandleStick(futureCandleStick); var sRsiList = new List <decimal>(); var rsiLenList = rsi.rsi.Take(_shochRsiLength).ToList(); var maxRsi = rsiLenList.Max(); var minRsi = rsiLenList.Min(); decimal shochrsi; if (maxRsi - minRsi != 0) { shochrsi = (rsi.Value - minRsi) / (maxRsi - minRsi); } else { shochrsi = 0; } sRsiList.Add(shochrsi); sRsiList.AddRange(stochRsi.Take(100)); stochRsi = sRsiList; CalculateKandD(); }
internal static void Display(Candlestick candlestick) { lock (ConsoleSync) { Console.WriteLine($" {candlestick.Symbol} - O: {candlestick.Open:0.00000000} H: {candlestick.High:0.00000000} L: {candlestick.Low:0.00000000} C: {candlestick.Close:0.00000000} V: {candlestick.Volume:0.00} [{candlestick.OpenTime.ToTimestamp()}]"); } }
public void AddCandleStick(Candlestick candleStick) { var diff = _closePrices.First() - candleStick.Close; var list = new List <decimal>(); List <decimal> avgGain = new List <decimal>(); List <decimal> avgLoss = new List <decimal>(); List <decimal> rsiList = new List <decimal>(); list.Add(candleStick.Close); list.AddRange(_closePrices.Take(100)); _closePrices = list; var t1 = (_avgGain.First() * (_length - 1) + (diff > 0 ? diff : 0)) / _length; var t2 = (_avgLoss.First() * (_length - 1) + (diff < 0 ? -diff : 0)) / _length; avgGain.Add(t1); avgLoss.Add(t2); rsiList.Add(GetRsi(avgGain.First(), avgLoss.First())); avgGain.AddRange(_avgGain.Take(100)); avgLoss.AddRange(_avgLoss.Take(100)); rsiList.AddRange(rsi.Take(100)); rsi = rsiList; _avgGain = avgGain; _avgLoss = avgLoss; }
public Trend getTrend(Candlestick candlestick) { double midPoint = calculateMidPoint(candlestick); if (candlestick.Quote > midPoint) return Trend.Bullish; if (candlestick.Quote < midPoint) return Trend.Bearish; return Trend.UnTrended; }
public void Throws() { var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); const long firstTradeId = 1234567890; const long lastTradeId = 1234567899; const bool isFinal = true; var symbol = Symbol.BTC_USDT; const CandlestickInterval interval = CandlestickInterval.Hour; const long openTime = 1234567890; const decimal open = 4950; const decimal high = 5100; const decimal low = 4900; const decimal close = 5050; const decimal volume = 1000; const long closeTime = 2345678901; const long quoteAssetVolume = 5000000; const int numberOfTrades = 555555; const decimal takerBuyBaseAssetVolume = 4444; const decimal takerBuyQuoteAssetVolume = 333; var candlestick = new Candlestick(symbol, interval, openTime, open, high, low, close, volume, closeTime, quoteAssetVolume, numberOfTrades, takerBuyBaseAssetVolume, takerBuyQuoteAssetVolume); using (var cts = new CancellationTokenSource()) { Assert.Throws <ArgumentException>("timestamp", () => new CandlestickEventArgs(-1, cts.Token, candlestick, firstTradeId, lastTradeId, isFinal)); Assert.Throws <ArgumentException>("timestamp", () => new CandlestickEventArgs(0, cts.Token, null, firstTradeId, lastTradeId, isFinal)); Assert.Throws <ArgumentNullException>("candlestick", () => new CandlestickEventArgs(timestamp, cts.Token, null, firstTradeId, lastTradeId, isFinal)); Assert.Throws <ArgumentException>("firstTradeId", () => new CandlestickEventArgs(timestamp, cts.Token, candlestick, -2, lastTradeId, isFinal)); Assert.Throws <ArgumentException>("lastTradeId", () => new CandlestickEventArgs(timestamp, cts.Token, candlestick, firstTradeId, -2, isFinal)); Assert.Throws <ArgumentException>("lastTradeId", () => new CandlestickEventArgs(timestamp, cts.Token, candlestick, firstTradeId, firstTradeId - 1, isFinal)); } }
public void Equality() { var symbol = Symbol.BTC_USDT; const CandlestickInterval interval = CandlestickInterval.Hour; var openTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); const decimal open = 4950; const decimal high = 5100; const decimal low = 4900; const decimal close = 5050; const decimal volume = 1000; var closeTime = DateTimeOffset.FromUnixTimeMilliseconds(openTime).AddHours(1).ToUnixTimeMilliseconds(); const long quoteAssetVolume = 5000000; const int numberOfTrades = 555555; const decimal takerBuyBaseAssetVolume = 4444; const decimal takerBuyQuoteAssetVolume = 333; var candlestick = new Candlestick(symbol, interval, openTime, open, high, low, close, volume, closeTime, quoteAssetVolume, numberOfTrades, takerBuyBaseAssetVolume, takerBuyQuoteAssetVolume); var serializer = new CandlestickSerializer(); var json = serializer.Serialize(candlestick); var other = serializer.Deserialize(json); Assert.True(candlestick.Equals(other)); }
public void Properties() { var symbol = Symbol.BTC_USDT; const CandlestickInterval interval = CandlestickInterval.Hour; var openTime = DateTimeOffset.FromUnixTimeMilliseconds(DateTime.UtcNow.ToTimestamp()).UtcDateTime; const decimal open = 4950; const decimal high = 5100; const decimal low = 4900; const decimal close = 5050; const decimal volume = 1000; var closeTime = openTime.AddHours(1); const long quoteAssetVolume = 5000000; const int numberOfTrades = 555555; const decimal takerBuyBaseAssetVolume = 4444; const decimal takerBuyQuoteAssetVolume = 333; var candlestick = new Candlestick(symbol, interval, openTime, open, high, low, close, volume, closeTime, quoteAssetVolume, numberOfTrades, takerBuyBaseAssetVolume, takerBuyQuoteAssetVolume); Assert.Equal(symbol, candlestick.Symbol); Assert.Equal(interval, candlestick.Interval); Assert.Equal(openTime, candlestick.OpenTime); Assert.Equal(open, candlestick.Open); Assert.Equal(high, candlestick.High); Assert.Equal(low, candlestick.Low); Assert.Equal(close, candlestick.Close); Assert.Equal(volume, candlestick.Volume); Assert.Equal(closeTime, candlestick.CloseTime); Assert.Equal(quoteAssetVolume, candlestick.QuoteAssetVolume); Assert.Equal(numberOfTrades, candlestick.NumberOfTrades); Assert.Equal(takerBuyBaseAssetVolume, candlestick.TakerBuyBaseAssetVolume); Assert.Equal(takerBuyQuoteAssetVolume, candlestick.TakerBuyQuoteAssetVolume); }
private static void Display(Candlestick candlestick) { lock (_sync) { _candlesticks[candlestick.Symbol] = candlestick; if (_displayTask.IsCompleted) { // Delay to allow multiple data updates between display updates. _displayTask = Task.Delay(100) .ContinueWith(_ => { Candlestick[] latestCandlesticks; lock (_sync) { latestCandlesticks = _candlesticks.Values.ToArray(); } Console.SetCursorPosition(0, 0); foreach (var c in latestCandlesticks) { Console.WriteLine($" {c.Symbol} - O: {c.Open:0.00000000} | H: {c.High:0.00000000} | L: {c.Low:0.00000000} | C: {c.Close:0.00000000} | V: {c.Volume:0.00} - [{c.OpenTime.ToTimestamp()}]".PadRight(119)); Console.WriteLine(); } Console.WriteLine(message); }); } } }
private PatternViewModel CreatePVM(Ticker ticker, List <Candlestick> listOfCandlesticks) { PatternViewModel pvm = new PatternViewModel(); var CandlesticksForValidTickers = listOfCandlesticks.FindAll(x => x.Symbol == ticker.Symbol); if (CandlesticksForValidTickers.Count > 0) { pvm.Symbol = ticker.Symbol; pvm.Price = ticker.Price.ToString(); pvm.AskPrice = ticker.AskPrice.ToString(); pvm.PatternType = "BULLFLAG"; for (int i = 0; i < CandlesticksForValidTickers.Count; i++) { Candlestick candlestick = CandlesticksForValidTickers[i]; pvm.Interval = candlestick.Interval; pvm.OpenTimes.Add(Convert.ToDouble(candlestick.OpenTime)); pvm.Opens.Add(candlestick.Open); pvm.Highs.Add(candlestick.High); pvm.Lows.Add(candlestick.Low); pvm.Closes.Add(candlestick.Close); pvm.Volumes.Add(candlestick.Volume); pvm.CloseTimes.Add(Convert.ToDouble(candlestick.CloseTime)); pvm.QuoteAssetVolumes.Add(candlestick.QuoteAssetVolume); pvm.NumberOfTrades.Add(Convert.ToInt32(candlestick.NumberOfTrades)); pvm.TakerBuyBaseAssetVolume.Add(candlestick.TakerBuyBaseAssetVolume); pvm.TakerBuyQuoteAssetVolume.Add(candlestick.TakerBuyQuoteAssetVolume); } return(pvm); } return(null); }
internal static void Display(Candlestick candlestick) { lock (ConsoleSync) { Console.WriteLine($" {candlestick.Symbol} - O: {candlestick.Open:0.00000000} | H: {candlestick.High:0.00000000} | L: {candlestick.Low:0.00000000} | C: {candlestick.Close:0.00000000} | V: {candlestick.Volume:0.00} - [{candlestick.OpenTime}]"); } }
private List <Candlestick> GetCandlesticks(string ticker, string interval, string limit) { HttpClientHandler handler = new HttpClientHandler(); handler.DefaultProxyCredentials = CredentialCache.DefaultCredentials; List <Candlestick> listOfCandlesticks = new List <Candlestick>(); HttpClient client = new HttpClient(handler); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Authorization"); string query = "/api/v1/klines?symbol=" + ticker + "&interval=" + interval + "&limit=" + limit; var result = client.GetAsync(new Uri(burl + query)).Result; if (result.IsSuccessStatusCode) { string myContent = result.Content.ReadAsStringAsync().Result; var candlestickRange = JsonConvert.DeserializeObject <List <List <string> > >(myContent); foreach (var candlestick in candlestickRange) { Candlestick cvm = new Candlestick(ticker, candlestick); listOfCandlesticks.Add(cvm); } return(listOfCandlesticks); //WriteToTextFile(listOfCandlesticks); //return View(listOfCandlesticks); } return(null); }
//************************************************************************************** /// <summary> /// Load candlesticks from DB. /// </summary> public static List <Candlestick> LoadFromDB(string iTableName) { var results = new List <Candlestick>(); using (var connection = new SqlConnection(Program.SQLConnectionName)) { connection.Open(); var sql = "Select * from " + iTableName; var command = new SqlCommand(sql, connection); using (var reader = command.ExecuteReader()) { while (reader.Read()) { var startTime = Utils.DateTimeToUnix(reader.GetDateTime(0)); var endTime = Utils.DateTimeToUnix(reader.GetDateTime(1)); var openPrice = (float)reader.GetDouble(2); var closePrice = (float)reader.GetDouble(3); var highPrice = (float)reader.GetDouble(4); var lowPrice = (float)reader.GetDouble(5); var medianPrice = (float)reader.GetDouble(6); var c = new Candlestick(startTime, endTime, openPrice, closePrice, highPrice, lowPrice, medianPrice); results.Add(c); } } } return(results); }
protected override void OnBar() { // Put your core logic here cs2 = this.GetMarketSeries(1); cs3 = this.GetMarketSeries(2); Print("{0}", cs2.OpenTime.ToLocalTime().ToString("dd MMM yy HH:mm")); if ( cs2.Height.IsPositive() && cs3.Height.IsPositive() && cs2.Height / cs3.Height >= TriggerHeightRatio && cs2.High < cs3.High && cs2.Low < cs3.Low && cs2.CloseToLowHeight / cs3.CloseToLowHeight >= TriggerHLRatio ) { //BUY ExecuteMarketOrder(TradeType.Buy, Symbol.Name, Volume, string.Empty, StopLossPips > 0 ? new Nullable <double>(StopLossPips) : null, TakeProfitPips > 0 ? new Nullable <double>(TakeProfitPips) : null); } if ( cs2.Height.IsPositive() && cs3.Height.IsPositive() && cs2.Height / cs3.Height >= TriggerHeightRatio && cs2.High > cs3.High && cs2.Low > cs3.Low && cs2.HighToCloseHeight / cs3.HighToCloseHeight >= TriggerHLRatio ) { //SELL ExecuteMarketOrder(TradeType.Sell, Symbol.Name, Volume, string.Empty, StopLossPips > 0 ? new Nullable <double>(StopLossPips) : null, TakeProfitPips > 0 ? new Nullable <double>(TakeProfitPips) : null); } }
public void Insert(Candlestick candlestick, string exchange = "Binance") { var openTime = new DateTime(candlestick.OpenTime.Year, candlestick.OpenTime.Month, candlestick.OpenTime.Day, candlestick.OpenTime.Hour, candlestick.OpenTime.Minute, 0); var closeTime = new DateTime(candlestick.CloseTime.Year, candlestick.CloseTime.Month, candlestick.CloseTime.Day, candlestick.CloseTime.Hour, candlestick.CloseTime.Minute, 0); var sql = @"INSERT INTO public.klines(""openTime"", open, high, low, close, ""closeTime"", ""quoteAssetVolume"", ""numberOfTrades"", ""baseVolume"", ""quoteVolume"", symbol, exchange) VALUES(@openTime, @open, @high, @low, @close, @closeTime, @quoteAssetVolume, @numberOfTrades, @baseVolume, @quoteVolume, @symbol, @exchange); "; var parameters = new { openTime, open = candlestick.Open, high = candlestick.High, low = candlestick.Low, close = candlestick.Close, volume = candlestick.Volume, closeTime, quoteAssetVolume = candlestick.QuoteAssetVolume, numberOfTrades = candlestick.NumberOfTrades, baseVolume = candlestick.TakerBuyBaseAssetVolume, quoteVolume = candlestick.TakerBuyQuoteAssetVolume, symbol = candlestick.Symbol, exchange }; using (IDbConnection connection = Connection) { connection.Execute(sql, parameters); } }
public void Add(Candlestick futureCandleStick) { //kdb c = new kdb("localhost", 5000); List <Candlestick> list = new List <Candlestick>(); list.Add(futureCandleStick); list.AddRange(_candleSticks); _candleSticks = list; foreach (KeyValuePair <int, Sma> keyValuePair in Sma) { keyValuePair.Value.AddCandleStick(futureCandleStick); //c.k($"insert[`MA](`{pair};\"Z\"$ \"{futureCandleStick.OpenDateTime:yyyy-MM-ddTHH:mm:ss:fffff}\"; `SMA; {keyValuePair.Key.ToString()}; \"f\"${keyValuePair.Value.Value})"); } foreach (KeyValuePair <int, Ema> keyValuePair in Ema) { keyValuePair.Value.AddCandleStick(futureCandleStick); // c.k($"insert[`MA](`{pair};\"Z\"$ \"{futureCandleStick.OpenDateTime:yyyy-MM-ddTHH:mm:ss:fffff}\"; `EMA;{keyValuePair.Key.ToString()}; \"f\"${keyValuePair.Value.Value})"); } foreach (KeyValuePair <int, Gsma> keyValuePair in Gsma) { keyValuePair.Value.AddCandleStick(futureCandleStick); //c.k($"insert[`MA](`{pair};\"Z\"$ \"{futureCandleStick.OpenDateTime:yyyy-MM-ddTHH:mm:ss:fffff}\"; `GSMA; {keyValuePair.Key.ToString()}; \"f\"${keyValuePair.Value.Value*10000000000})"); } stochRsi.AddCandleStick(futureCandleStick); //c.k($"insert[`Oscillator](`{pair};\"Z\"$ \"{futureCandleStick.OpenDateTime:yyyy-MM-ddTHH:mm:ss:fffff}\"; `SRSI; \"f\"${ stochRsi.KValue};\"f\"${stochRsi.DValue})"); rsi.AddCandleStick(futureCandleStick); //c.k($"insert[`Oscillator](`{pair};\"Z\"$ \"{futureCandleStick.OpenDateTime:yyyy-MM-ddTHH:mm:ss:fffff}\"; `RSI; \"f\"${ rsi.Value};0.0)"); macd.AddCandleStick(futureCandleStick); //c.k($"insert[`Oscillator](`{pair};\"Z\"$ \"{futureCandleStick.OpenDateTime:yyyy-MM-ddTHH:mm:ss:fffff}\"; `MACD; \"f\"${ macd.MacdLine.First()*100000000};\"f\"${macd.SignalLine.First()*100000000})"); }
public void Properties() { var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); const long firstTradeId = 1234567890; const long lastTradeId = 1234567899; const bool isFinal = true; var symbol = Symbol.BTC_USDT; const CandlestickInterval interval = CandlestickInterval.Hour; const long openTime = 1234567890; const decimal open = 4950; const decimal high = 5100; const decimal low = 4900; const decimal close = 5050; const decimal volume = 1000; const long closeTime = 2345678901; const long quoteAssetVolume = 5000000; const int numberOfTrades = 555555; const decimal takerBuyBaseAssetVolume = 4444; const decimal takerBuyQuoteAssetVolume = 333; var candlestick = new Candlestick(symbol, interval, openTime, open, high, low, close, volume, closeTime, quoteAssetVolume, numberOfTrades, takerBuyBaseAssetVolume, takerBuyQuoteAssetVolume); using (var cts = new CancellationTokenSource()) { var args = new CandlestickEventArgs(timestamp, cts.Token, candlestick, firstTradeId, lastTradeId, isFinal); Assert.Equal(timestamp, args.Timestamp); Assert.Equal(candlestick, args.Candlestick); Assert.Equal(firstTradeId, args.FirstTradeId); Assert.Equal(lastTradeId, args.LastTradeId); Assert.Equal(isFinal, args.IsFinal); } }
static LineProtocolPoint Convert(this Candlestick source) { if (source == null) { return(null); } var fields = new Dictionary <string, object> { { "high", source.High }, { "low", source.Low }, { "open", source.Open }, { "close", source.Close }, { "lowerWick", source.LowerWick }, { "upperWick", source.UpperWick }, }; // No Measurements to be inserted: if (fields.Count == 0) { return(null); } var tags = new Dictionary <string, string> { { "body_type", source.BodyType.ToString() }, // {"quality_code", source.QualityCode.ToString(CultureInfo.InvariantCulture)} }; return(new LineProtocolPoint("candles", new ReadOnlyDictionary <string, object>(fields), tags, DateTime.SpecifyKind(source.CloseTime, DateTimeKind.Utc))); }
public void AddCandleStick(Candlestick candleStick) { List <Candlestick> candlesticklist = new List <Candlestick>(); candlesticklist.Add(candleStick); candlesticklist.AddRange(_candleSticks.Take(100)); _candleSticks = candlesticklist; Fast.AddCandleStick(candleStick); Slow.AddCandleStick(candleStick); var diff = Fast.Value - Slow.Value; List <decimal> list = new List <decimal>(); list.Add(diff); list.AddRange(MacdLine.Take(100)); MacdLine = list; MacdLineEma.AddCandleStick(new Candlestick() { Close = diff }); list = new List <decimal>(); list.Add(diff - MacdLineEma.Value); list.AddRange(Histogram.Take(100)); Histogram = list; }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { JArray objects = JArray.Load(reader); var candles = new List <Candlestick>(); foreach (var obj in objects) { var candle = new Candlestick(); candle.OpenTime = (long)obj[0]; candle.Open = (decimal)obj[1]; candle.High = (decimal)obj[2]; candle.Low = (decimal)obj[3]; candle.Close = (decimal)obj[4]; candle.Volume = (decimal)obj[5]; candle.CloseTime = (long)obj[6]; candle.QuoteAssetVolume = (decimal)obj[7]; candle.NumberOfTrades = (long)obj[8]; candle.TakerBuyBaseAssetVolume = (decimal)obj[9]; candle.TakerBuyQuoteAssetVolume = (decimal)obj[10]; candles.Add(candle); } return(candles); }
private void CalculateCurrentEma(Candlestick futureCandleStick) { var list = new List <decimal>(); list.Add((futureCandleStick.Close - Value) * Multiplier + Value); list.AddRange(ema.Take(100)); ema = list; }
public void AddCandleStick(Candlestick futureCandleStick) { var list = new List <decimal>(); list.Add(futureCandleStick.Close); list.AddRange(_closePrices.Take(100)); _closePrices = list; CalculateCurrentEma(futureCandleStick); }
public CandlestickPlus(Candlestick candlestick) { time = candlestick.time; bid = candlestick.bid; ask = candlestick.ask; mid = candlestick.mid; volume = candlestick.volume; complete = candlestick.complete; }
// LONGエントリー予約 public void reserveLongOrder(Candlestick _reserved_candle, int _fib_idx, double _fib_origin_high) { entry_state = OrderState.RESERVED; state = PositionState.LONG; reserved_price = _reserved_candle.last; reserved_candle = _reserved_candle; entry_fib_idx = _fib_idx; fib_origin_high = _fib_origin_high; return; }
public void AddCandleStick(Candlestick futureCandleStick) { var list = new List <decimal>(); list.Add(futureCandleStick.Close); list.AddRange(_closePrices.Take(100)); _closePrices = list; //_candleSticks = list.OrderByDescending(x=>x.CloseDateTime); CalculateCurrentSma(); }
// SHORTエントリー予約 public void reserveShortOrder(Candlestick _reserved_candle, int _fib_idx, double _fib_origin_low) { entry_state = OrderState.RESERVED; state = PositionState.SHORT; reserved_price = _reserved_candle.last; reserved_candle = _reserved_candle; entry_fib_idx = _fib_idx; fib_origin_low = _fib_origin_low; return; }
//************************************************************************************** /// <summary> /// Creates and returns a new candlestick list that is the copy of provided list with range [iStartIndex; iEndIndex]. /// </summary> public static List <Candlestick> CreateCopy(List <Candlestick> iCandlesticks, int iStartIndex, int iEndIndex) { if (iCandlesticks is null) { throw new ArgumentNullException(nameof(iCandlesticks)); } Candlestick[] results = new Candlestick[iEndIndex - iStartIndex + 1]; iCandlesticks.CopyTo(iStartIndex, results, 0, results.Length); return(new List <Candlestick>(results)); }
//************************************************************************************** /// <summary> /// Creates and returns array containing average prices starting with iIndex-iPeriods up to iIndex. /// </summary> public static float[] CreatePriceArray(List <Candlestick> iCandlestickData, int iPeriods, int iIndex) { Candlestick[] rawData = new Candlestick[iPeriods]; iCandlestickData.CopyTo(iIndex - iPeriods + 1, rawData, 0, iPeriods); if (rawData[rawData.Length - 1] != iCandlestickData[iIndex]) { throw new SystemException("Last element mismatch."); } return(rawData.Select(x => x.ClosePrice).ToArray()); }
//************************************************************************************** /// <summary> /// Retrieves candlesticks from a server. /// </summary> public static List <Candlestick> RetrieveCandlesticks(Candlestick.Period iCandlestickPeriod) { HttpWebRequest request; switch (iCandlestickPeriod) { case Candlestick.Period.D1: request = (HttpWebRequest)WebRequest.Create("https://www.alphavantage.co/query?function=FX_DAILY&from_symbol=EUR&to_symbol=USD&apikey=" + kAlphaVantageAPIKey + "&datatype=csv&outputsize=full"); break; case Candlestick.Period.m1: request = (HttpWebRequest)WebRequest.Create("https://www.alphavantage.co/query?function=FX_INTRADAY&from_symbol=EUR&to_symbol=USD&interval=1min&apikey=" + kAlphaVantageAPIKey + "&datatype=csv&outputsize=full"); break; case Candlestick.Period.m5: request = (HttpWebRequest)WebRequest.Create("https://www.alphavantage.co/query?function=FX_INTRADAY&from_symbol=EUR&to_symbol=USD&interval=5min&apikey=" + kAlphaVantageAPIKey + "&datatype=csv&outputsize=full"); break; case Candlestick.Period.m15: request = (HttpWebRequest)WebRequest.Create("https://www.alphavantage.co/query?function=FX_INTRADAY&from_symbol=EUR&to_symbol=USD&interval=15min&apikey=" + kAlphaVantageAPIKey + "&datatype=csv&outputsize=full"); break; case Candlestick.Period.m30: request = (HttpWebRequest)WebRequest.Create("https://www.alphavantage.co/query?function=FX_INTRADAY&from_symbol=EUR&to_symbol=USD&interval=30min&apikey=" + kAlphaVantageAPIKey + "&datatype=csv&outputsize=full"); break; default: throw new ArgumentException("Unsuported candlestick period", "iCandlestickPeriod"); } HttpWebResponse response = (HttpWebResponse)request.GetResponse(); if (response.StatusCode != HttpStatusCode.OK) { throw new Exception("Could not load candlesticks."); } using (Stream stream = response.GetResponseStream()) using (StreamReader reader = new StreamReader(stream)) { List <Candlestick> results = Candlestick.LoadCSV(reader, iCandlestickPeriod, 0); results.Reverse(); // Remove not full periods. if (Utils.UnixToDateTime(results[results.Count - 1].EndTime) > DateTime.UtcNow) { results.RemoveAt(results.Count - 1); } return(results); } }
internal bool IsTimeToSell(Candlestick LastClosed) { bool bRet = (!bsBot.EnableBB || (bsBot.EnableBB && LastClosed.High > bb.Top.Last(1))) && (!bsBot.EnableRSI || (bsBot.EnableRSI && rsi.Result.Last(1) > bsBot.RSIUpperLevel)) && (!bsBot.EnableADX || (bsBot.EnableADX && adx.ADX.Last(1) < bsBot.DMSLevel)) && (bsBot.Aggressive || (!bsBot.Aggressive && Positions.Count() == 0)); if (bRet) { bsBot.Print("LastClosed.High: {0} > BB Top: {1}, RSI: {2} > RSIUpperLevel: {3}", LastClosed.High, bb.Top.Last(1), rsi.Result.Last(1), bsBot.RSIUpperLevel); } return(bRet); }
public double calculateMidPoint(Candlestick candlestick) { return (candlestick.HighPrice + candlestick.LowPrice) / 2; }