Example #1
0
            public void AddToDictionary(TimeSeriesItem item)
            {
                if (_dictionary.TryGetValue(item.DocId, out var itemsList) == false)
                {
                    _dictionary[item.DocId] = itemsList = new List <TimeSeriesItem>();
                }

                itemsList.Add(item);
            }
        private List <TimeSeriesItem> ExtractTimeSeriesData(DataSet dataset)
        {
            if (dataset.Data == null)
            {
                return(null);
            }

            List <TimeSeriesItem> timeseries = new List <TimeSeriesItem>();

            for (int i = 0; i < dataset.Data.Count; i++)
            {
                int dateIndex   = dataset.ColumnNames.IndexOf("Date");
                int highIndex   = dataset.ColumnNames.IndexOf("High");
                int lowIndex    = dataset.ColumnNames.IndexOf("Low");
                int openIndex   = dataset.ColumnNames.IndexOf("Open");
                int closeIndex  = dataset.ColumnNames.IndexOf("Close");
                int volumeIndex = dataset.ColumnNames.IndexOf("Traded Volume");

                string dateAsString = (string)dataset.Data[i][dateIndex];

                TimeSeriesItem dataEntry = new TimeSeriesItem
                {
                    Date = DateTime.ParseExact(dateAsString, "yyyy-MM-dd", CultureInfo.InvariantCulture),
                };

                if (highIndex != -1 && dataset.Data[i][highIndex] != null)
                {
                    dataEntry.High = (double)dataset.Data[i][highIndex];
                }

                if (lowIndex != -1 && dataset.Data[i][lowIndex] != null)
                {
                    dataEntry.Low = (double)dataset.Data[i][lowIndex];
                }

                if (openIndex != -1 && dataset.Data[i][openIndex] != null)
                {
                    dataEntry.Open = (double)dataset.Data[i][openIndex];
                }

                if (closeIndex != -1 && dataset.Data[i][closeIndex] != null)
                {
                    dataEntry.Close = (double)dataset.Data[i][closeIndex];
                }

                if (volumeIndex != -1 && dataset.Data[i][volumeIndex] != null)
                {
                    dataEntry.TradedVolume = (double)dataset.Data[i][volumeIndex];
                }

                timeseries.Add(dataEntry);
            }

            return(timeseries);
        }
Example #3
0
            public async ValueTask WriteTimeSeriesAsync(TimeSeriesItem item)
            {
                if (First == false)
                {
                    Writer.WriteComma();
                }
                First = false;

                Writer.WriteStartObject();
                {
                    Writer.WritePropertyName(Constants.Documents.Blob.Document);

                    Writer.WriteStartObject();
                    {
                        Writer.WritePropertyName(nameof(TimeSeriesItem.DocId));
                        Writer.WriteString(item.DocId);
                        Writer.WriteComma();

                        Writer.WritePropertyName(nameof(TimeSeriesItem.Name));
                        Writer.WriteString(item.Name);
                        Writer.WriteComma();

                        Writer.WritePropertyName(nameof(TimeSeriesItem.ChangeVector));
                        Writer.WriteString(item.ChangeVector);
                        Writer.WriteComma();

                        Writer.WritePropertyName(nameof(TimeSeriesItem.Collection));
                        Writer.WriteString(item.Collection);
                        Writer.WriteComma();

                        Writer.WritePropertyName(nameof(TimeSeriesItem.Baseline));
                        Writer.WriteDateTime(item.Baseline, true);
                    }
                    Writer.WriteEndObject();

                    Writer.WriteComma();
                    Writer.WritePropertyName(Constants.Documents.Blob.Size);
                    Writer.WriteInteger(item.SegmentSize);
                }
                Writer.WriteEndObject();

                unsafe
                {
                    Writer.WriteMemoryChunk(item.Segment.Ptr, item.Segment.NumberOfBytes);
                }

                await Writer.MaybeFlushAsync();
            }
        public void OnNewGroupEvent(GroupEvent groupEvent)
        {
            var group = groupEvent.Group;

            switch (groupEvent.Obj.TypeId)
            {
            case DataObjectType.TimeSeriesItem:
                TimeSeriesItem timeSeriesItem = groupEvent.Obj as TimeSeriesItem;
//                    this.manager.GetLogList(group.Fields["StrategyName"].Value.ToString(), group.Fields["Symbol"].Value.ToString())[group.Fields["LogName"].Value.ToString()].Add(timeSeriesItem.DateTime, (object) timeSeriesItem.Value);
                break;

            case DataObjectType.Text:
                TextInfo textInfo = groupEvent.Obj as TextInfo;
//                    this.manager.GetLogList(group.Fields["StrategyName"].Value.ToString(), group.Fields["Symbol"].Value.ToString())[group.Fields["LogName"].Value.ToString()].Add(textInfo.DateTime, (object) textInfo.Content);
                break;
            }
        }
Example #5
0
        /// <summary>
        /// VAR0:=(2*CLOSE+HIGH+LOW)/4;
        /// B:=XMA((VAR0-LLV(LOW,30))/(HHV(HIGH,30)-LLV(LOW,30))*100,12);
        /// 主力做多资金:EMA(B,3),LINETHICK2,COLORWHITE;
        /// </summary>
        /// <param name="kline"></param>
        /// <param name="begin"></param>
        /// <param name="end"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public static TimeSeries <ITimeSeriesItem <List <double> > > executeIndicator(this KLine kline, int begin = 0, int end = 0, PropertyDescriptorCollection param = null)
        {
            TimeSeries <ITimeSeriesItem <double> > close = kline.Select <double>("CLOSE", begin, end);
            TimeSeries <ITimeSeriesItem <double> > open  = kline.Select <double>("OPEN", begin, end);
            TimeSeries <ITimeSeriesItem <double> > high  = kline.Select <double>("HIGH", begin, end);
            TimeSeries <ITimeSeriesItem <double> > low   = kline.Select <double>("LOW", begin, end);
            TimeSeries <ITimeSeriesItem <double> > VAR0  = (close * 2.0 + high + low) / 4;


            TimeSeries <ITimeSeriesItem <double> > t1 = VAR0 - low.LLV(20);
            TimeSeries <ITimeSeriesItem <double> > t2 = high.HHV(20) - low.LLV(20);

            TimeSeries <ITimeSeriesItem <double> > t3 = (t1 / t2) * 100;

            //TimeSeries<ITimeSeriesItem<double>> B = t3.XMA(12);
            TimeSeries <ITimeSeriesItem <double> > B = t3.EMA(12);

            TimeSeries <ITimeSeriesItem <double> > mainforces = B.EMA(3);

            TimeSeries <ITimeSeriesItem <double> > retailInverstors = mainforces.EMA(30);


            TimeSeries <ITimeSeriesItem <List <double> > > results = new TimeSeries <ITimeSeriesItem <List <double> > >();

            foreach (ITimeSeriesItem <double> mainforce in mainforces)
            {
                TimeSeriesItem <List <double> > r = new TimeSeriesItem <List <double> >();
                r.Value = new List <double>(new double[2] {
                    0, 0
                });

                r.Date     = mainforce.Date;
                r.Value[0] = mainforce.Value;

                ITimeSeriesItem <double> retailInverstor = retailInverstors[r.Date];
                r.Value[1] = retailInverstor == null ? 0 : retailInverstor.Value;

                results.Add(r);
            }
            return(results);
        }
        /// <summary>
        /// 资金动向交叉点创建
        /// </summary>
        /// <param name="tu"></param>
        /// <returns></returns>
        public TimeSeries <ITimeSeriesItem <double> > FundTrendCrossCreate(TimeUnit tu)
        {
            TimeSeries <ITimeSeriesItem <List <double> > > ts = this.CreateOrLoad <TimeSeries <ITimeSeriesItem <List <double> > > >(IndicatorMetaCollection.NAME_FUND_TREND, tu);

            if (ts == null)
            {
                return(null);
            }
            TimeSeries <ITimeSeriesItem <double> > corss = new TimeSeries <ITimeSeriesItem <double> >();
            double prevflag = ts[0].Value[0] - ts[0].Value[1];

            for (int i = 1; i < ts.Count; i++)
            {
                double flag = ts[i].Value[0] - ts[i].Value[1];
                if (prevflag < 0 && flag > 0)
                {
                    TimeSeriesItem <double> item = new TimeSeriesItem <double>()
                    {
                        Date  = ts[i].Date,
                        Value = flag
                    };
                    corss.Add(item);
                }
                else if (prevflag > 0 && flag < 0)
                {
                    TimeSeriesItem <double> item = new TimeSeriesItem <double>()
                    {
                        Date  = ts[i].Date,
                        Value = flag
                    };
                    corss.Add(item);
                }
                prevflag = flag;
            }
            return(corss);
        }
Example #7
0
        /// <summary>
        /// 买线:EMA(CLOSE,3),COLORRED,LINETHICK1;
        /// 卖线:EMA(SLOPE(CLOSE,21)*20+CLOSE,42),COLORBLUE,LINETHICK2;
        /// </summary>
        /// <param name="kline"></param>
        /// <returns></returns>
        public static TradingLine indicator_trading_stereo1(this KLine kline, int begin = 0, int end = 0)
        {
            TimeSeries <ITimeSeriesItem <double> > close = kline.Select <double>("close", begin, end);

            TimeSeries <ITimeSeriesItem <double> > buyLine       = close.EMA(3);
            TimeSeries <ITimeSeriesItem <double> > sellLine      = (close.SLOPE(21) * 20 + close).EMA(42);
            TimeSeries <ITimeSeriesItem <char> >   buysellPoints = new TimeSeries <ITimeSeriesItem <char> >();

            int buy_gt_sell = 1, sell_gt_buy = 2; //买大于卖为1,卖大于买为2
            int state = 0;                        //前一个状态

            for (int i = 0; i < buyLine.Count; i++)
            {
                ITimeSeriesItem <double> buyItem  = buyLine[i];
                ITimeSeriesItem <double> sellItem = sellLine[buyItem.Date];
                if (sellItem == null)
                {
                    continue;
                }
                double t = buyItem.Value - sellItem.Value;
                if (t == 0)
                {
                    continue;
                }
                if (state == 0)
                {
                    state = t > 0 ? buy_gt_sell : sell_gt_buy;
                    continue;
                }
                int cs = t > 0 ? buy_gt_sell : sell_gt_buy;
                if (cs == state)
                {
                    continue;
                }

                if (state == buy_gt_sell)
                {
                    TimeSeriesItem <char> v = new TimeSeriesItem <char>()
                    {
                        Date  = buyItem.Date,
                        Value = 'S'
                    };
                    buysellPoints.Add(v);
                }
                else if (state == sell_gt_buy)
                {
                    TimeSeriesItem <char> v = new TimeSeriesItem <char>()
                    {
                        Date  = buyItem.Date,
                        Value = 'B'
                    };
                    buysellPoints.Add(v);
                }
                state = cs;
            }

            return(new TradingLine()
            {
                buyLine = buyLine,
                sellLine = sellLine,
                buysellPoints = buysellPoints
            });
        }
Example #8
0
        // TODO: review it
        public override void Paint(object obj, Pad pad)
        {
            var ts = obj as TimeSeries;

            if (ts == null || ts.Count == 0)
            {
                return;
            }
            double          xmin = pad.XMin;
            double          xmax = pad.XMax;
            double          ymin = pad.YMin;
            double          ymax = pad.YMax;
            List <Property> list = null;

            if (this.metadata.TryGetValue(obj, out list))
            {
                foreach (var property in list)
                {
                    if (property.Name == "Color")
                    {
                        this.Color = (Color)property.Value;
                    }
                    if (property.Name == "Width")
                    {
                        this.DrawWidth = (int)property.Value;
                    }
                    if (property.Name == "Style")
                    {
                        if ((string)property.Value == "Line")
                        {
                            this.DrawStyle = DrawStyle.Line;
                        }
                        if ((string)property.Value == "Bar")
                        {
                            this.DrawStyle = DrawStyle.Bar;
                        }
                        if ((string)property.Value == "Circle")
                        {
                            this.DrawStyle = DrawStyle.Circle;
                        }
                    }
                }
            }
            var      pen       = new Pen(Color, DrawWidth);
            int      num1      = 0;
            double   num2      = 0.0;
            double   num3      = 0.0;
            long     num4      = 0L;
            long     num5      = 0L;
            int      num6      = 0;
            int      num7      = 0;
            long     num8      = 0L;
            long     num9      = 0L;
            int      num10     = 0;
            int      num11     = 0;
            DateTime datetime1 = new DateTime((long)xmin);
            DateTime datetime2 = new DateTime((long)xmax);
            int      num12     = !(datetime1 < ts.FirstDateTime) ? ts.GetIndex(datetime1, IndexOption.Prev) : 0;
            int      num13     = !(datetime2 > ts.LastDateTime) ? ts.GetIndex(datetime2, IndexOption.Next) : ts.Count - 1;

            if (num12 == -1 || num13 == -1)
            {
                return;
            }
            for (int index = num12; index <= num13; ++index)
            {
                TimeSeriesItem timeSeriesItem = ts.GetItem(index);
                double         num14          = (double)timeSeriesItem.DateTime.Ticks;
                pad.ClientX(num14);
                double num15 = timeSeriesItem.Value;
                if (this.DrawStyle == DrawStyle.Line)
                {
                    if (num1 != 0)
                    {
                        num4 = (long)pad.ClientX(num2);
                        num6 = pad.ClientY(num3);
                        num5 = (long)pad.ClientX(num14);
                        num7 = pad.ClientY(num15);
                        if ((pad.IsInRange(num14, num15) || pad.IsInRange(num2, num3)) &&
                            (num4 != num8 || num5 != num9 || (num6 != num10 || num7 != num11)))
                        {
                            pad.Graphics.DrawLine(pen, (float)num4, (float)num6, (float)num5, (float)num7);
                        }
                    }
                    num8  = num4;
                    num10 = num6;
                    num9  = num5;
                    num11 = num7;
                    num2  = num14;
                    num3  = num15;
                    ++num1;
                }
                if (this.DrawStyle == DrawStyle.Bar)
                {
                    if (num15 > 0.0)
                    {
                        pad.Graphics.FillRectangle(new SolidBrush(Color), pad.ClientX(num14) - (this.DrawWidth + 1) / 2, pad.ClientY(num15), this.DrawWidth + 1, pad.ClientY(0.0) - pad.ClientY(num15));
                    }
                    else
                    {
                        pad.Graphics.FillRectangle(new SolidBrush(Color), pad.ClientX(num14) - (this.DrawWidth + 1) / 2, pad.ClientY(0.0), this.DrawWidth + 1, pad.ClientY(num15) - pad.ClientY(0.0));
                    }
                }
                if (this.DrawStyle == DrawStyle.Circle)
                {
                    var solidBrush = new SolidBrush(Color);
                    pad.Graphics.FillEllipse(solidBrush, pad.ClientX(num14) - this.DrawWidth / 2, pad.ClientY(num15) - this.DrawWidth / 2, this.DrawWidth, this.DrawWidth);
                }
            }
        }