コード例 #1
0
        private void TestExtremum(T value, int id, ExtremumType extremumType)
        {
            Collection <DataFieldInfo> dataFields = DataObjectInfo <T> .GetDataFields(DataFieldMask.Data);

            // Set the value
            foreach (DataFieldInfo field in dataFields)
            {
                Type fieldType = field.Field.FieldType;

                if (fieldType.IsValueType && fieldType.IsPrimitive)
                {
                    DataObjectInfo <T> .SetProperty(field, value, Extremum(fieldType, extremumType));
                }
            }

            // Save the object
            DataObjectFactory <T> .WriteObject(value);

            value = DataObjectFactory <T> .CreateObject(id);

            // Verify the value
            foreach (DataFieldInfo field in dataFields)
            {
                Type fieldType = field.Field.FieldType;

                if (fieldType.IsValueType && fieldType.IsPrimitive)
                {
                    object storedValue = field.Field.GetValue(value);
                    Assert.AreEqual(Extremum(fieldType, extremumType), storedValue, string.Format("#17 - {0}: Maximum value should store correctly.", FormatFieldName(field)));
                }
            }
        }
コード例 #2
0
ファイル: Interpolation.cs プロジェクト: t9mike/ADK
        /// <summary>
        /// Finds local extremum of the function on a segment
        /// </summary>
        /// <param name="x">Argument values, defining segment points</param>
        /// <param name="y">Function values on the segment</param>
        /// <param name="extremum">Type of extremum (maximum or minimum)</param>
        /// <param name="epsilon">Expected accuracy</param>
        /// <param name="x0">Output value of X-coordinate of the extremum</param>
        /// <param name="y0">Output value of Y-coordinate of the extremum</param>
        private static void FindExtremum(double[] x, double[] y, ExtremumType extremum, double epsilon, out double x0, out double y0)
        {
            if (x.Length != y.Length)
            {
                throw new ArgumentException("Array sizes do not match.");
            }

            if (x.Length < 2)
            {
                throw new ArgumentException("Arrays must contain at least 2 points.");
            }

            // X-coordinate of extremum point
            x0 = 0;

            // left edge of the segment
            double a = x[0];

            // right edge of the segment
            double b = x[x.Length - 1];

            // golden ratio
            double ratio = 1.61803399;

            do
            {
                double x1 = b - (b - a) / ratio;
                double x2 = a + (b - a) / ratio;
                double y1 = Lagrange(x, y, x1);
                double y2 = Lagrange(x, y, x2);

                if ((extremum == ExtremumType.Max && y1 <= y2) ||
                    (extremum == ExtremumType.Min && y1 >= y2))
                {
                    a = x1;
                }
                else
                {
                    b = x2;
                }
                x0 = (a + b) / 2;
            }while (Math.Abs(b - a) > epsilon);

            y0 = Lagrange(x, y, x0);
        }
コード例 #3
0
ファイル: PriceProcessor.cs プロジェクト: mielk/waluty
        protected bool CheckForExtremum(DataItem item, ExtremumType type, bool fromScratch)
        {
            Extremum extremum;

            if (!fromScratch)
            {
                //Jeżeli analiza nie jest przeprowadzana od początku, sprawdzane jest czy dla tego DataItemu
                //przypisany jest obieket ExtremumCalculator danego typu. Jeżeli nie, oznacza to, że już
                //wcześniej został zdyskwalifikowany i nie ma sensu go sprawdzać.
                extremum = item.Price.GetExtremumObject(type);
                if (extremum == null) return false;
                if (!extremum.IsOpen) return false;

                //Sprawdź czy notowania późniejsze względem tego pozwalają uznać je za ekstremum.
                var laterCounter = CountSerie(item.Index, type.IsPeak(), type.ByClose(), false);
                if (laterCounter < MinRange && laterCounter < (analyzer.getDataItemsLength() - 1 - item.Index))
                {
                    extremum.Cancelled = true;
                    item.Price.ApplyExtremumValue(type, null);
                    item.Price.IsUpdated = true;
                    return true;
                }
                else
                {
                    extremum.LaterCounter = laterCounter;
                }

            }
            else
            {
                //Wartości oparte na wcześniejszych notowaniach obliczane są tylko, jeżeli analiza wykonywana jest od zera.
                var earlierCounter = CountSerie(item.Index, type.IsPeak(), type.ByClose(), true);
                var laterCounter = CountSerie(item.Index, type.IsPeak(), type.ByClose(), false);

                //Jeżeli liczba wcześniejszych lub późniejszych notowań gorszych od tego notowania nie osiągnęła
                //minimalnego poziomu, to notowanie jest dyskwalifikowane jako ekstremum i nie ma sensu go dalej sprawdzać.
                if (earlierCounter < MinRange) return false;
                if (laterCounter < MinRange && laterCounter < (analyzer.getDataItemsLength() - 1 - item.Index)) return false;

                extremum = new Extremum(item.Date, atf, type.IsPeak(), type.ByClose());
                extremum.EarlierCounter = earlierCounter;
                extremum.LaterCounter = laterCounter;
                extremum.EarlierAmplitude = FindEarlierPriceAmplitude(type, item, getCurrentExtremum(type));
                extremum.EarlierChange1 = GetPriceChange(item, extremum, true, 1);
                extremum.EarlierChange2 = GetPriceChange(item, extremum, true, 2);
                extremum.EarlierChange3 = GetPriceChange(item, extremum, true, 3);
                extremum.EarlierChange5 = GetPriceChange(item, extremum, true, 5);
                extremum.EarlierChange10 = GetPriceChange(item, extremum, true, 10);
                extremum.Volatility = item.Quotation.Volatility();

                //Calculate [LaterAmplitude] for previous extremum.
                var prevExtremumDataItem = getCurrentExtremum(type);
                if (prevExtremumDataItem != null)
                {
                    var prevExtremum = prevExtremumDataItem.Extremum(type);
                    if (prevExtremum != null)
                    {
                        var laterAmplitude = FindLaterPriceAmplitude(type, prevExtremumDataItem, item);
                        prevExtremum.LaterAmplitude = laterAmplitude;
                        prevExtremumDataItem.Price.IsUpdated = true;
                    }
                }

            }

            //Właściwie, to już wcześniej zostało zapewnione, że do tego miejsca wykonanie programu dotrze
            //tylko, jeżeli extremum nie jest puste, ale mimo to kompilator nie przepuszcza bez takiego warunku tutaj.
            if (extremum != null)
            {
                //extremum.LaterAmplitude = FindPriceAmplitude(item, extremum, false);
                if (extremum.LaterChange1 == null) extremum.LaterChange1 = GetPriceChange(item, extremum, false, 1);
                if (extremum.LaterChange2 == null) extremum.LaterChange2 = GetPriceChange(item, extremum, false, 2);
                if (extremum.LaterChange3 == null) extremum.LaterChange3 = GetPriceChange(item, extremum, false, 3);
                if (extremum.LaterChange5 == null) extremum.LaterChange5 = GetPriceChange(item, extremum, false, 5);
                if (extremum.LaterChange10 == null) extremum.LaterChange10 = GetPriceChange(item, extremum, false, 10);
                extremum.IsOpen = (item.Index + extremum.LaterCounter == analyzer.getDataItemsLength() - 1) || quotationsLeft(item) < 10;
                if (extremum.IsConfirmed())
                {
                    setCurrentExtremum(type, item);
                }
                item.Price.ApplyExtremumValue(type, extremum);
                item.Price.IsUpdated = true;
            }

            return true;
        }
コード例 #4
0
ファイル: PriceProcessor.cs プロジェクト: mielk/waluty
 private void setCurrentExtremum(ExtremumType type, DataItem item)
 {
     currentExtrema[type] = item;
 }
コード例 #5
0
ファイル: PriceProcessor.cs プロジェクト: mielk/waluty
 private DataItem getCurrentExtremum(ExtremumType type)
 {
     DataItem item;
     if (currentExtrema.TryGetValue(type, out item))
     {
         return item;
     }
     return null;
 }
コード例 #6
0
ファイル: PriceProcessor.cs プロジェクト: mielk/waluty
        protected double FindLaterPriceAmplitude(ExtremumType type, DataItem item, DataItem nextExtremum)
        {
            int startIndex = item.Index + 1;
            int endIndex = nextExtremum.Index - 1;
            var itemsRange = analyzer.getDataItems().Where(i => i.Index >= startIndex && i.Index <= endIndex);

            if (itemsRange.Count() == 0) return 0;

            double oppositeValue = (type.IsPeak() ?
                                        itemsRange.Min(i => i.Quotation.Low) :
                                        itemsRange.Max(i => i.Quotation.High));
            double baseValue = item.Quotation.ProperValue(type);

            return Math.Abs(oppositeValue - baseValue) / Math.Max(oppositeValue, baseValue);
        }
コード例 #7
0
ファイル: PriceProcessor.cs プロジェクト: mielk/waluty
        protected double FindEarlierPriceAmplitude(ExtremumType type, DataItem item, DataItem prevExtremum)
        {
            int startIndex;
            int endIndex;

            startIndex = (prevExtremum == null ? 0 : prevExtremum.Index);
            endIndex = item.Index - 1;
            IEnumerable<DataItem> items = analyzer.getDataItems();
            var itemsRange = items.Where(i => i.Index >= startIndex && i.Index <= endIndex);
            if (itemsRange.Count() == 0) return 0;
            double oppositeValue = (type.IsPeak() ?
                                        itemsRange.Min(i => i.Quotation.Low) :
                                        itemsRange.Max(i => i.Quotation.High));
            double baseValue = item.Quotation.ProperValue(type);

            return Math.Abs(oppositeValue - baseValue) / Math.Max(oppositeValue, baseValue);
        }
コード例 #8
0
ファイル: Price.cs プロジェクト: mielk/waluty
 public Extremum GetExtremumObject(ExtremumType type)
 {
     switch (type)
     {
         case ExtremumType.PeakByClose:
             return PeakByCloseExtremum;
         case ExtremumType.PeakByHigh:
             return PeakByHighExtremum;
         case ExtremumType.TroughByClose:
             return TroughByCloseExtremum;
         case ExtremumType.TroughByLow:
             return TroughByLowExtremum;
         default:
             return null;
     }
 }
コード例 #9
0
ファイル: Price.cs プロジェクト: mielk/waluty
 public void ApplyExtremumValue(ExtremumType type, Extremum extremum)
 {
     switch (type)
     {
         case ExtremumType.PeakByClose:
             PeakByCloseExtremum = extremum;
             PeakByClose = extremum == null ? 0 : extremum.Evaluate();
             break;
         case ExtremumType.PeakByHigh:
             PeakByHighExtremum= extremum;
             PeakByHigh = extremum == null ? 0 : extremum.Evaluate();
             break;
         case ExtremumType.TroughByClose:
             TroughByCloseExtremum = extremum;
             TroughByClose = extremum == null ? 0 : extremum.Evaluate();
             break;
         case ExtremumType.TroughByLow:
             TroughByLowExtremum = extremum;
             TroughByLow = extremum == null ? 0 : extremum.Evaluate();
             break;
     }
 }
コード例 #10
0
        private object Extremum(Type dataType, ExtremumType extremumType)
        {
            if (dataType == typeof(bool))
            {
                switch (extremumType)
                {
                case ExtremumType.Maximum:
                    return(true);

                case ExtremumType.Minimum:
                    return(false);
                }
            }
            if (dataType == typeof(byte))
            {
                switch (extremumType)
                {
                case ExtremumType.Maximum:
                    return(byte.MaxValue);

                case ExtremumType.Minimum:
                    return(byte.MinValue);
                }
            }
            else if (dataType == typeof(short))
            {
                switch (extremumType)
                {
                case ExtremumType.Maximum:
                    return(short.MaxValue);

                case ExtremumType.Minimum:
                    return(short.MinValue);
                }
            }
            else if (dataType == typeof(int))
            {
                switch (extremumType)
                {
                case ExtremumType.Maximum:
                    return(int.MaxValue);

                case ExtremumType.Minimum:
                    return(int.MinValue);
                }
            }
            else if (dataType == typeof(long))
            {
                switch (extremumType)
                {
                case ExtremumType.Maximum:
                    return(long.MaxValue);

                case ExtremumType.Minimum:
                    return(long.MinValue);
                }
            }
            else if (dataType == typeof(float))
            {
                switch (extremumType)
                {
                case ExtremumType.Maximum:
                    return(float.MaxValue);

                case ExtremumType.Minimum:
                    return(float.MinValue);
                }
            }
            else if (dataType == typeof(double))
            {
                switch (extremumType)
                {
                case ExtremumType.Maximum:
                    return(double.MaxValue);

                case ExtremumType.Minimum:
                    return(double.MinValue);
                }
            }
            else if (dataType == typeof(decimal))
            {
                switch (extremumType)
                {
                case ExtremumType.Maximum:
                    return(decimal.MaxValue);

                case ExtremumType.Minimum:
                    return(decimal.MinValue);
                }
            }

            throw new NotSupportedException();
        }
コード例 #11
0
ファイル: Quotation.cs プロジェクト: mielk/waluty
 public double ProperValue(ExtremumType extremumType)
 {
     switch (extremumType)
     {
         case ExtremumType.PeakByClose:
         case ExtremumType.TroughByClose:
             return Close;
         case ExtremumType.PeakByHigh:
             return High;
         case ExtremumType.TroughByLow:
             return Low;
         default:
             return Close;
     }
 }
コード例 #12
0
ファイル: HelperMethods.cs プロジェクト: mielk/waluty
 public static bool IsOpposite(this ExtremumType type, ExtremumType tested)
 {
     if (type == ExtremumType.PeakByClose || type == ExtremumType.PeakByHigh)
     {
         return (tested == ExtremumType.TroughByClose || tested == ExtremumType.TroughByLow);
     }
     else
     {
         return (tested == ExtremumType.PeakByClose || tested == ExtremumType.PeakByHigh);
     }
 }
コード例 #13
0
ファイル: DataItem.cs プロジェクト: mielk/waluty
 public Extremum Extremum(ExtremumType type)
 {
     if (Price == null) return null;
     Extremum extremum = Price.GetExtremumObject(type);
     if (extremum == null || extremum.Cancelled) return null;
     return extremum;
 }