Пример #1
0
        private void OnSubscription(SubscribedResponse response)
        {
            _streams.SubscriptionSubject.OnNext(response);

            var channelId = response.ChanId;

            // ********************
            // ADD HANDLERS BELOW
            // ********************

            switch (response.Channel)
            {
            case "ticker":
                _channelIdToHandler[channelId] = (data, config) =>
                                                 Ticker.Handle(data, response, config, _streams.TickerSubject);
                break;

            case "trades":
                //if pair is null means that is funding
                if (response.Pair == null)
                {
                    _channelIdToHandler[channelId] = (data, config) =>
                                                     Funding.Handle(data, response, config, _streams.FundingsSubject);
                }
                else
                {
                    _channelIdToHandler[channelId] = (data, config) =>
                                                     Trade.Handle(data, response, config, _streams.TradesSubject, _streams.TradesSnapshotSubject);
                }
                break;

            case "candles":
                _channelIdToHandler[channelId] = (data, config) =>
                                                 Candles.Handle(data, response, _streams.CandlesSubject);
                break;

            case "book":
                _channelIdToHandler[channelId] = (data, config) =>
                                                 Book.Handle(data, response, config, _streams.BookSubject, _streams.BookSnapshotSubject, _streams.BookChecksumSubject);
                break;

            case "status":
                if (response.Key.StartsWith("deriv"))
                {
                    _channelIdToHandler[channelId] = (data, config) =>
                                                     DerivativePairStatus.Handle(data, response, _streams.DerivativePairSubject);
                }

                if (response.Key.StartsWith("liq"))
                {
                    _channelIdToHandler[channelId] = (data, config) =>
                                                     LiquidationFeedStatus.Handle(data, response, _streams.LiquidationFeedSubject);
                }

                break;
                //default:
                //    Log.Warning($"Missing subscription handler '{response.Channel}'");
                //    break;
            }
        }
        public TestHistoricalData(int timeframe, string filename)
        {
            this.timeframe = timeframe;
            //считать данные из файла
            string text = ReadStringFromFile(filename);

            if (text != null)
            {
                text = text.Replace("\r", "");
                List <string> str = text.Split('\n').ToList();
                str.RemoveAt(0);
                str.RemoveAt(0);
                int i = 0;
                foreach (string v in str)
                {
                    var s = v.Split('/');
                    //var c = new TestCandle();
                    try
                    {
                        var c = new TestCandle()
                        {
                            Open    = Convert.ToDouble(s[1]),
                            High    = Convert.ToDouble(s[2]),
                            Low     = Convert.ToDouble(s[3]),
                            Close   = Convert.ToDouble(s[4]),
                            TimeUTC = i * timeframe * 60
                        };
                        Candles.Add(c);
                        i++;
                    }
                    catch { }
                }
            }
        }
Пример #3
0
        public void CandleUpdate(DateTime time, double open, double close, double high, double low, bool end)
        {
            if (CurrentCandle == null || time != CurrentCandle.Time)
            {
                if (AverageOpen > 0 && Candles.Count >= AverageOpen)
                {
                    var up = CurrentCandle.Close > CurrentCandle.Open;

                    open = Candles.Reverse().Take(AverageOpen).Average(c => (c.Close + (up ? c.Low : c.High)) / 2);
                }

                CurrentCandle = new CandleData
                {
                    Time      = time,
                    Open      = open,
                    Close     = close,
                    High      = high,
                    Low       = low,
                    LastPrice = close
                };
            }
            else
            {
                CurrentCandle.Close     = close;
                CurrentCandle.High      = high;
                CurrentCandle.Low       = low;
                CurrentCandle.LastPrice = close;
            }
        }
Пример #4
0
        /// <summary>
        /// take candles from exchange with needed timeframe
        /// получить с биржи свечи нужного ТФ
        /// </summary>
        /// <param name="tf"></param>
        /// <param name="security"></param>
        /// <returns></returns>
        private List <List <double> > GetBitfinexCandles(string tf, string security, int count, DateTime start, DateTime end)
        {
            try
            {
                Thread.Sleep(8000);
                Dictionary <string, string> param = new Dictionary <string, string>();

                if (start != DateTime.MinValue)
                {
                    param.Add("trade:" + tf, ":t" + security + "/hist" + "?"
                              + "limit=" + count
                              //+ "&start=" + (start - new DateTime(1970, 1, 1)).TotalMilliseconds);
                              + "&end=" + (end - new DateTime(1970, 1, 1)).TotalMilliseconds);
                }
                else
                {
                    param.Add("trade:" + tf, ":t" + security + "/hist" + "?limit=" + count);
                }

                var candles    = _client.GetCandles(param);
                var candleHist = Candles.FromJson(candles);

                return(candleHist);
            }
            catch (Exception e)
            {
                SendLogMessage(e.ToString(), LogMessageType.Error);
                return(null);
            }
        }
Пример #5
0
        public void RelativeStrengthIndexHappyFlow()
        {
            var input = Candles.Take(10);
            var rsi   = input.RelativeStrengthIndex();

            Assert.Equal(47.348886532343584305408271475M, rsi);
        }
Пример #6
0
        /// <summary>
        /// Reinject all patterns
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Candles_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add && Candles.Count() > 2)
            {
                // will be migrated to TA Node

                //var RawData = Candles.Select(y => y.Candle).ToList();
                //var indexdcandles = new IndexedCandle(RawData, RawData.Count() - 1);
                //var LastBinanceCandle = (BinanceCandle)e.NewItems[0];
                //LastBinanceCandle.Properties.Add("Bearish",indexdcandles.IsBearish());
                //LastBinanceCandle.Properties.Add("IsBullish", indexdcandles.IsBullish());
                //LastBinanceCandle.Properties.Add("IsAccumDistBearish", indexdcandles.IsAccumDistBearish());
                //LastBinanceCandle.Properties.Add("IsAccumDistBullish", indexdcandles.IsAccumDistBullish());
                //LastBinanceCandle.Properties.Add("ClosePricePercentageChange", indexdcandles.ClosePricePercentageChange());
                //LastBinanceCandle.Properties.Add("ClosePriceChange", indexdcandles.ClosePriceChange());
                //LastBinanceCandle.Properties.Add("IsBreakingHistoricalHighestClose", indexdcandles.IsBreakingHistoricalHighestClose());
                //LastBinanceCandle.Properties.Add("IsBreakingHistoricalHighestHigh", indexdcandles.IsBreakingHistoricalHighestHigh());
                //LastBinanceCandle.Properties.Add("IsBreakingHistoricalLowestLow", indexdcandles.IsBreakingHistoricalLowestLow());
                //LastBinanceCandle.Properties.Add("IsObvBearish", indexdcandles.IsObvBearish());
                //LastBinanceCandle.Properties.Add("IsObvBullish", indexdcandles.IsObvBullish());
            }

            Task.Run(() =>
            {
                System.Threading.Thread.Sleep(1000);
                Candles.Purge();
            });
        }
Пример #7
0
        public void RateOfChangeNegative()
        {
            var data = Candles.Skip(2).Take(3);
            var roc  = data.RateOfChange();

            Assert.Equal(-0.151061173533083645443196005M, roc);
        }
        private void TLastCUpdate(object state)
        {
            if (LockCandlesUpdate)
            {
                return;
            }

            if (Candles.Count == 0)
            {
                return;
            }

            LockCandlesUpdate = true;

            Ticker tmp = Stock.GetMarketPrice(Param.Market, Print).Result;

            if (tmp == null)
            {
                LockCandlesUpdate = false;
                return;
            }
            decimal price = (tmp.Ask + tmp.Bid) / 2;

            Candles.Last().Close = price;

            OnUpdateCandles(Candles);
            LockCandlesUpdate = false;
        }
 public List <Candle> StraichCandles(Candles series)
 {/*
   * if (series.CandlesArray != null &&
   * series.CandlesArray.Count > 2)
   * {
   *     Candle standart = series.CandlesArray[0];
   *     TimeSpan timeBetwenCandles =
   *         series.CandlesArray[series.CandlesArray.Count - 2].TimeStart - series.CandlesArray[series.CandlesArray.Count - 1].TimeStart;
   *
   *     DateTime lastTime = series.CandlesArray[0].TimeStart;
   *
   *     int indexInsert = 0;
   *
   *     while (series.CandlesArray.Count < 205)
   *     {
   *         lastTime = lastTime.Add(timeBetwenCandles);
   *
   *         Candle newCandle = new Candle();
   *
   *         newCandle.Volume = standart.Volume;
   *         newCandle.Open = standart.Open;
   *         newCandle.High = standart.High;
   *         newCandle.Low = standart.Low;
   *         newCandle.Close = standart.Close;
   *         newCandle.TimeStart = lastTime;
   *
   *         series.CandlesArray.Insert(0, newCandle);
   *     }
   * }*/
     return(series.CandlesArray);
 }
Пример #10
0
        private List <Candle> ParseCandles(Candles candles)
        {
            try
            {
                List <Candle> osCandles = new List <Candle>();

                foreach (var candle in candles.Candle)
                {
                    osCandles.Add(new Candle()
                    {
                        Open      = Convert.ToDecimal(candle.Open.Replace(".", ",")),
                        High      = Convert.ToDecimal(candle.High.Replace(".", ",")),
                        Low       = Convert.ToDecimal(candle.Low.Replace(".", ",")),
                        Close     = Convert.ToDecimal(candle.Close.Replace(".", ",")),
                        Volume    = Convert.ToDecimal(candle.Volume.Replace(".", ",")),
                        TimeStart = DateTime.Parse(candle.Date),
                    });
                }

                return(osCandles);
            }
            catch (Exception e)
            {
                return(null);
            }
        }
Пример #11
0
        public List <MACD> MACD(int fastPeriod = 12, int slowPeriod = 26, int signalPeriod = 9)
        {
            int startIndex, count;

            double[]    macd          = new double[Candles.Count];
            double[]    macdSignal    = new double[Candles.Count];
            double[]    macdHistogram = new double[Candles.Count];
            List <MACD> macdData      = new List <MACD>();

            TA.Core.Macd(0, Candles.Count - 1, Candles.Select(quote => (double)quote.Close).ToArray(), fastPeriod, slowPeriod, signalPeriod, out startIndex, out count, macd, macdSignal, macdHistogram);

            for (int index = 0; index < macd.Length; ++index)
            {
                macdData.Add(new MACD()
                {
                    Value     = (decimal)macd[index],
                    Signal    = (decimal)macdSignal[index],
                    Histogram = (decimal)macdHistogram[index],
                });
            }
            macdData = macdData.Take(count).ToList();
            if (macdData.Count > 0)
            {
            }
            return(macdData);
        }
Пример #12
0
 public HistoryEventArgs(Candles candles)
 {
     SecurityId = candles.SecurityId;
     Period     = candles.Period;
     Status     = (CandlesStatus)candles.Status;
     Candles    = new List <Candle>(candles.CandlesArray ?? new Candle[0]);
 }
Пример #13
0
        /// <summary>
        /// take candles from exchange with needed timeframe
        /// получить с биржи свечи нужного ТФ
        /// </summary>
        /// <param name="tf"></param>
        /// <param name="security"></param>
        /// <returns></returns>
        private List <List <double> > GetBitfinexCandles(string tf, string security, int count)
        {
            try
            {
                Thread.Sleep(8000);
                Dictionary <string, string> param = new Dictionary <string, string>();
                param.Add("trade:" + tf, ":t" + security + "/hist" + "?limit=" + count);
                var candles    = _client.GetCandles(param);
                var candleHist = Candles.FromJson(candles);

                /* param = new Dictionary<string, string>();
                 * param.Add("trade:" + tf, ":t" + security + "/last");
                 * var lastCandle = _client.GetCandles(param);
                 * var candleLast = LastCandle.FromJson(lastCandle);
                 *
                 * candleHist.Add(candleLast);*/

                return(candleHist);
            }
            catch (Exception e)
            {
                SendLogMessage(e.ToString(), LogMessageType.Error);
                return(null);
            }
        }
        public int DeleteCandles(IEnumerable<ICandle> candlesToDelete)
        {
            var ticksToDelete = candlesToDelete
                .Select(c => GetIntervalTick(c.Timestamp, c.TimeInterval))
                .ToHashSet();

            return Candles.RemoveAll(c =>
                ticksToDelete.Contains(c.Tick));
        }
Пример #15
0
        private void OnCandles(Candles candles)
        {
            var ev = RecieveHistory;

            if (ev != null)
            {
                ev(this, new HistoryEventArgs(candles));
            }
        }
Пример #16
0
        /// <summary>
        /// из коннектора пришли новые данные
        /// </summary>
        private void BotTabIndex_NewCandlesChangeEvent(List <Candle> candles)
        {
            for (int i = 0; i < Tabs.Count; i++)
            {
                List <Candle> myCandles = Tabs[i].Candles(true);
                if (myCandles == null || myCandles.Count < 10)
                {
                    return;
                }
            }

            DateTime time = Tabs[0].Candles(true)[Tabs[0].Candles(true).Count - 1].TimeStart;

            for (int i = 0; i < Tabs.Count; i++)
            {
                List <Candle> myCandles = Tabs[i].Candles(true);
                if (myCandles[myCandles.Count - 1].TimeStart != time)
                {
                    return;
                }
            }
            // цикл для сбоа всех свечей в один массив

            if (string.IsNullOrWhiteSpace(ConvertedFormula))
            {
                return;
            }

            string nameArray = Calculate(ConvertedFormula);

            if (_valuesToFormula != null && !string.IsNullOrWhiteSpace(nameArray))
            {
                ValueForm val = _valuesToFormula.Find(v => v.Name == nameArray);

                if (val != null)
                {
                    Candles = val.ValueCandles;

                    for (int i = 1; i < Candles.Count; i++)
                    {
                        if (Candles[i].TimeStart == Candles[i - 1].TimeStart)
                        {
                            Candles.RemoveAt(i);
                            i--;
                        }
                    }

                    _chartMaster.SetCandles(Candles);

                    if (SpreadChangeEvent != null)
                    {
                        SpreadChangeEvent(Candles);
                    }
                }
            }
        }
Пример #17
0
        public List <decimal> EMA(int period)
        {
            int startIndex, count;

            double[] ema = new double[Candles.Count];

            TA.Core.Ema(0, Candles.Count - 1, Candles.Select(quote => (float)quote.Close).ToArray(), period, out startIndex, out count, ema);

            return(ema.Select(x => (decimal)x).Take(ema.Count() - period + 1).ToList());
        }
Пример #18
0
        public List <decimal> WilliamR(int period)
        {
            int startIndex, count;

            double[] willR = new double[Candles.Count];

            TA.Core.WillR(0, Candles.Count - 1, Candles.Select(quote => (double)quote.High).ToArray(), Candles.Select(quote => (double)quote.Low).ToArray(), Candles.Select(quote => (double)quote.Close).ToArray(), period, out startIndex, out count, willR);

            return(willR.Select(x => (decimal)x).ToList());
        }
Пример #19
0
        public decimal RSI(int period = 14)
        {
            int startIndex, count;

            double[] rsi = new double[Candles.Count];

            TA.Core.Rsi(0, Candles.Count - 1, Candles.Select(quote => (double)quote.Close).ToArray(), period, out startIndex, out count, rsi);

            return(rsi.Select(x => (decimal)x).Where(x => x != 0).LastOrDefault());
        }
Пример #20
0
        public void AddCandle()
        {
            Candle old_cndl = Candles[Candles.Count - 1] as Candle;
            Candle new_cndl = new Candle()
            {
                O = old_cndl.O, H = old_cndl.H, L = old_cndl.L, C = old_cndl.C, V = old_cndl.V, t = old_cndl.t
            };

            Candles.Add(new_cndl);
        }
Пример #21
0
        public List <decimal> SMA(int period)
        {
            int startIndex, count;

            double[] sma = new double[Candles.Count];

            TA.Core.Sma(0, Candles.Count - 1, Candles.Select(quote => quote.Close).Cast <float>().ToArray(), period, out startIndex, out count, sma);

            return(sma.Select(x => (decimal)x).ToList());
        }
        private async Task UpdateCandles()
        {
            Candles = await Stock.GetCandles(Param.Market, Param.Interval, 50, Print);

            if (Candles != null)
            {
                LastCandleTime = Candles.Last().Time;
                Print(string.Format("Загружено {0} свечей.", Candles.Count), true);
            }
        }
Пример #23
0
        private List <Trade> GetBitFinexTrades(string security, int count, DateTime end)
        {
            try
            {
                Thread.Sleep(8000);
                Dictionary <string, string> param = new Dictionary <string, string>();

                if (end == DateTime.MaxValue)
                {
                    param.Add("", "t" + security + "/hist" + "?"
                              + "limit=" + count);
                }
                else
                {
                    param.Add("", "t" + security + "/hist" + "?"
                              + "limit=" + count
                              + "&end=" + (end - new DateTime(1970, 1, 1)).TotalMilliseconds);
                }

                var response = _client.GetTrades(param);

                var tradesHist = Candles.FromJson(response);

                List <Trade> trades = new List <Trade>();

                for (int i = 0; i < tradesHist.Count; i++)
                {
                    DateTime time = new DateTime(1970, 1, 1) + TimeSpan.FromMilliseconds(tradesHist[i][1]);

                    Trade newTrade = new Trade();
                    newTrade.Time             = time;
                    newTrade.SecurityNameCode = security;
                    double vol = tradesHist[i][2];
                    newTrade.Volume = Math.Abs(Convert.ToDecimal(vol));
                    newTrade.Price  = Convert.ToDecimal(tradesHist[i][3]);
                    if (vol > 0)
                    {
                        newTrade.Side = Side.Buy;
                    }
                    else
                    {
                        newTrade.Side = Side.Sell;
                    }

                    trades.Insert(0, newTrade);
                }

                return(trades);
            }
            catch (Exception e)
            {
                SendLogMessage(e.ToString(), LogMessageType.Error);
                return(null);
            }
        }
Пример #24
0
        public Candles UpdateCandle(Candles candleUpdate)
        {
            var candle = SearchById(candleUpdate.ID);

            candle.Name  = candleUpdate.Name;
            candle.Scent = candleUpdate.Scent;
            candle.Color = candleUpdate.Color;
            candle.Price = candleUpdate.Price;

            return(candle);
        }
Пример #25
0
        Candles CreateCandle(string name, string color, string scent, double price)
        {
            var candle = new Candles()
            {
                Name  = name,
                Color = color,
                Scent = scent,
                Price = price,
            };

            return(candle);
        }
Пример #26
0
	// Use this for initialization
	void Start () {
		state = new bool[10];
		GameObject runeObject = gameObject.transform.Find ("Rune").gameObject;
		if (runeObject != null) {
			rune = runeObject.GetComponent<Rune> ();
		} 
		GameObject runeObject2 = gameObject.transform.Find ("Candles").gameObject;
		if (runeObject2 != null) {
			candles = runeObject2.GetComponent<Candles> ();
		} 
		changed ();
	}
Пример #27
0
        public List <Candle> GetChartData(CurrencyPair pair, EMarketTimeFrames tf, long time_beg, long time_end, CancellationToken?cancel = null)
        {
            // https://api.bitfinex.com/v2/candles/trade:TimeFrame:Symbol/Section
            var reply = GetData($"v2/candles/trade:{Misc.ToRequestString(tf)}:{pair.Id}/hist", cancel,
                                new KV("start", Misc.ToUnixTime(time_beg) * 1000),
                                new KV("end", Misc.ToUnixTime(time_end) * 1000),
                                new KV("sort", -1));

            // Update the chart data for the given pair
            Candles.ParseUpdate(pair, tf, JArray.Parse(reply));
            return(Candles[pair, tf]);
        }
Пример #28
0
        public CryptoTraderStats StartFromFile(string market)
        {
            _market = market;
            var prices = Candles.Select(c => CreateTicker(_market, c.Low, c.High, c.Timestamp)).ToList();

            _trades.Add(CreateTrade(_market, prices[0], Strategy.Settings.TradingBudget));
            foreach (var ticker in prices)
            {
                UpdateTicker(ticker);
            }
            GetStats();
            return(_stats);
        }
Пример #29
0
			public void Reset()
			{
				Candles.Clear();
				_prevValue = 0;
				_longPosition = false;
				_xp = 0;
				_af = 0;
				_prevBar = 0;
				_afIncreased = false;
				_reverseBar = 0;
				_reverseValue = 0;
				_prevSar = 0;
				_todaySar = 0;
			}
Пример #30
0
        /*/// <summary>
         * /// Get all candles with specif resolution for selected currencyPair.
         * /// </summary>
         * /// <param name="currencyPair">Currency pair code string, example BTC-USD.</param>
         * /// <param name="resolution">Select candle resolution.</param>
         * /// <returns>Candles data object.</returns>
         * public Candles GetCandlesData(string currencyPair, CandleResolution resolution)
         * {
         *  Candles candles = SendCandleChartDataRequest(currencyPair + "/" + resolution.GetSecond());
         *  candles.Resoluton = resolution;
         *
         *  return candles;
         * }*/

        /// <summary>
        /// Get all candles with specif resolution for selected currencyPair, start result "fromTimeUnix" and end in "toTimeUnix".
        /// For get one candle time from and time to must be the same.
        /// </summary>
        /// <param name="currencyPair">Currency pair code string, example BTC-USD.</param>
        /// <param name="resolution">Select candle resolution.</param>
        /// <param name="fromTimeUnix">Unix timestamp from start geting candles.</param>
        /// <param name="toTimeUnix">Unix timestamp to end geting candles.</param>
        /// <returns>Candles data object.</returns>
        /// <exception cref="ArgumentException">Throw if "fromTimeUnix" is great than "toTimeUnix". From time must be before to time.</exception>
        public Candles GetCandlesData(string currencyPair, CandleResolution resolution, long fromTimeUnix, long toTimeUnix)
        {
            if (fromTimeUnix > toTimeUnix)
            {
                throw new ArgumentException("Date to must be leter(not equal) than date from!");
            }

            Dictionary <string, string> query = CreateCandleQuery(fromTimeUnix, toTimeUnix, resolution.GetSecond());

            Candles candles = SendCandleChartDataRequest(currencyPair + "/" + resolution.GetSecond(), query);

            candles.Resoluton = resolution;

            return(candles);
        }
Пример #31
0
        public Candles UpdateCandle(Candles candleUpdate)
        {
            var candleDB = this.ReadID(candleUpdate.ID);

            if (candleDB != null)
            {
                candleDB.Name  = candleUpdate.Name;
                candleDB.Scent = candleUpdate.Scent;
                candleDB.Color = candleUpdate.Color;
                candleDB.Price = candleUpdate.Price;

                return(candleDB);
            }
            return(null);
        }
Пример #32
0
    public static void RandomizeGame() {
        GameState.HadDrink = (GameState.Drink)Random.Range(0, (int)GameState.Drink.NumDrinks);
        GameState.Time = (GameState.TimeOfDay)Random.Range(0, 2);
        GameState.CandleLit = (GameState.Candles)Random.Range(0, 2);

        CorrectSymbols[0] = Random.Range(0, 6);
        CorrectSymbols[1] = Random.Range(CorrectSymbols[0] + 1, 7);
        CorrectSymbols[2] = Random.Range(CorrectSymbols[1] + 1, 8);
        CorrectSymbols[3] = Random.Range(CorrectSymbols[2] + 1, 9);
        CorrectSymbols[4] = Random.Range(CorrectSymbols[3] + 1, 10);

        if (Random.value > 0.5) {
            CorrectSymbols[0] = 0;
            CorrectSymbols[1] = 1;
            CorrectSymbols[2] = Random.Range(2, 8);
            CorrectSymbols[3] = Random.Range(CorrectSymbols[2]+1, 9);
            CorrectSymbols[4] = Random.Range(CorrectSymbols[3]+1, 10);
        } else {
            CorrectSymbols[0] = symbolSolutionD[CorrectSymbols[0]];
            CorrectSymbols[1] = symbolSolutionD[CorrectSymbols[1]];
            CorrectSymbols[2] = symbolSolutionD[CorrectSymbols[2]];
            CorrectSymbols[3] = symbolSolutionD[CorrectSymbols[3]];
            CorrectSymbols[4] = symbolSolutionD[CorrectSymbols[4]];
        }

        ActiveSymbols = CorrectSymbols.OrderBy(x => Random.value).ToArray();
        if (GameState.CandleLit == GameState.Candles.Lit) {
            CorrectSymbols = CorrectSymbols.Reverse().ToArray();
        }
    }