MatriksIQ Destek
Matriks Destek
Matriks Web Destek
Matriks Mobile Destek
0 beğenilme 0 beğenilmeme
114 kez görüntülendi

MERHABA 

aşağıda kodunu paylaştığım indikatörü matriks ıq ya uyarlayabilir misiniz?

namespace Matriks.Lean.Algotrader
{
    [Indicator(IsOverlay = true, AutoRescale = false, AccessRights = AccessRights.None)]
    public class ZigZagAndFiboLevels : Indicator
    {
        [Parameter("Deviation Percent", DefaultValue = 2, MinValue = 0.01)]
        public double deviationPercent { get; set; }
 
        [Parameter("Show Fibo Levels", DefaultValue = true)]
        public bool Allow_To_Show_Fibo_Levels { get; set; }
 
        [Parameter("Show Fibo Labels", DefaultValue = true)]
        public bool Allow_To_Show_Fibo_Labels { get; set; }
 
        [Parameter("Show Only Fibo %", DefaultValue = true)]
        public bool Allow_To_Show_Only_Fibo_Percent { get; set; }
 
        [Output("Zig Zag", Color = Colors.LightGray, Thickness = 1, PlotType = PlotType.Line)]
        public IndicatorDataSeries Value { get; set; }
 
        public enum Direction
        {
            Up,
            Down
        }
 
        private Direction direction = Direction.Up;
        private double Extremum_Price = 0.0;
        private double Extremum_Price_Up = 0.0;
        private double Extremum_Price_Down = 0.0;
        private int Extremum_Index = 0;
 
        /// used to remove objects
        private int Previous_Index = 0;
 
        //List<string> myCollection = new List<string>();
        //private string[] Objects = new string[1];
 
        public struct Result
        {
            public int? Index;
            public double? Value;
        }
 
        public Result Last_Extremum()
        {
            for (int index = Value.Count - 1; index >= 0; index--)
                if (!Value[index].Equals(Double.NaN))
                    return new Result 
                    {
                        Index = index,
                        Value = Value[index]
                    };
 
            return new Result 
            {
                Index = null,
                Value = null
            };
        }
 
        public double Extremum_Price_UP()
        {
            return Extremum_Price_Up;
        }
 
        public double Extremum_Price_DOWN()
        {
            return Extremum_Price_Down;
        }
 
 
        private void Move_Extremum(int index, double price)
        {
            //ChartObjects.RemoveObject("Info " + Extremum_Index);
 
            //for (int i = 0; i < Objects.Length; i++)
            //    if (Objects[i] != null)
            //    {
            //        Print("obj = {0}", Objects[i]);
            //        ChartObjects.RemoveObject(Objects[i]);
            //    }
 
            Value[Extremum_Index] = Double.NaN;
            Set_Extremum(index, price);
        }
 
        private void Set_Extremum(int index, double price)
        {
            if (Allow_To_Show_Fibo_Levels)
                Draw_Fibo_Levels(index, price);
            //ChartObjects.DrawText("Info " + index, price.ToString(), index, Extremum_Price < price ? price + 0.002 : price - 0.002, VerticalAlignment.Center, HorizontalAlignment.Center, Colors.Yellow);
 
            Extremum_Price_Up = direction == Direction.Up ? price : Extremum_Price_Up;
 
 
 
            Extremum_Price_Down = direction == Direction.Down ? price : Extremum_Price_Down;
 
            Print("Extremum_Price_Up = {0}       Extremum_Price_Down = {1}", Extremum_Price_Up, Extremum_Price_Down);
 
            Extremum_Index = index;
            Extremum_Price = price;
            Value[Extremum_Index] = Extremum_Price;
        }
 
        private void Draw_Fibo_Levels(int New_Index, double New_Extremum)
        {
            var LE = Last_Extremum();
            if (LE.Index == null || LE.Value == null)
                return;
 
            //0; 23,6; 38,2; 50; 61,8; 76,4; 100   
            //123.6 - 138.2 - 161.8 - 200.0 - 238.2 - 261.8 - 300.0 - 338.2 - 400.0 - 423.6 - 485.4 - 547.2 - 647.2 - 685.4 
 
            double First_Point = (double)LE.Value;
            double Second_Point = New_Extremum;
 
            double Value_0_00 = (double)LE.Value;
            double Value_23_6 = Fibo_Level(First_Point, Second_Point, 0.236);
            double Value_38_2 = Fibo_Level(First_Point, Second_Point, 0.382);
            double Value_50_0 = Fibo_Level(First_Point, Second_Point, 0.5);
            double Value_61_8 = Fibo_Level(First_Point, Second_Point, 0.618);
            double Value_76_4 = Fibo_Level(First_Point, Second_Point, 0.764);
            double Value_100_ = Fibo_Level(First_Point, Second_Point, 1.0);
            double Value_138_2 = Fibo_Level(First_Point, Second_Point, 1.382);
            double Value_161_8 = Fibo_Level(First_Point, Second_Point, 1.618);
            double Value_200_0 = Fibo_Level(First_Point, Second_Point, 2.0);
            double Value_261_8 = Fibo_Level(First_Point, Second_Point, 2.618);
            double Value_338_2 = Fibo_Level(First_Point, Second_Point, 3.382);
            double Value_423_6 = Fibo_Level(First_Point, Second_Point, 4.236);
            double Value_547_2 = Fibo_Level(First_Point, Second_Point, 5.472);
            double Value_685_4 = Fibo_Level(First_Point, Second_Point, 6.854);
 
            int Index = (int)LE.Index;
 
            Draw_Fibo_Level(Index, New_Index, Value_0_00, "0.00%", 1);
            Draw_Fibo_Level(Index, New_Index, Value_23_6, "23.6%", 2);
            Draw_Fibo_Level(Index, New_Index, Value_38_2, "38.2%", 3);
            Draw_Fibo_Level(Index, New_Index, Value_50_0, "50.0%", 4);
            Draw_Fibo_Level(Index, New_Index, Value_61_8, "61.6%", 5);
            Draw_Fibo_Level(Index, New_Index, Value_76_4, "76.4%", 6);
            Draw_Fibo_Level(Index, New_Index, Value_100_, "100.0%", 7);
            Draw_Fibo_Level(Index, New_Index, Value_138_2, "138.2%", 8);
            Draw_Fibo_Level(Index, New_Index, Value_161_8, "161.8%", 9);
            Draw_Fibo_Level(Index, New_Index, Value_200_0, "200.0%", 10);
            Draw_Fibo_Level(Index, New_Index, Value_261_8, "261.8%", 11);
            Draw_Fibo_Level(Index, New_Index, Value_338_2, "338.2%", 12);
            Draw_Fibo_Level(Index, New_Index, Value_423_6, "423.6%", 13);
            Draw_Fibo_Level(Index, New_Index, Value_547_2, "547.2%", 14);
            Draw_Fibo_Level(Index, New_Index, Value_685_4, "685.4%", 15);
 
            Previous_Index = (int)LE.Index;
        }
 
        private void Draw_Fibo_Level(int First_Point, int Second_Point, double Value, string Level, int Object_Number)
        {
            Colors color = Colors.DarkGray;
            double thickness = 0.5;
            LineStyle Line_Style = LineStyle.DotsRare;
 
            VerticalAlignment VA = VerticalAlignment.Center;
            HorizontalAlignment HA = HorizontalAlignment.Left;
 
            ChartObjects.DrawLine("Line" + Level + First_Point, First_Point, Value, Second_Point, Value, color, thickness, Line_Style);
 
            if (Allow_To_Show_Fibo_Labels)
                ChartObjects.DrawText("Text" + Level + First_Point, (Allow_To_Show_Only_Fibo_Percent ? "" : (Value.ToString() + " - ")) + Level, Second_Point, Value + 0.001, VA, HA, color);
        }
        /*
            Print("Objects.Length {0}", Objects.Length);
            Print("Objects Number {0}", Object_Number);
 
            if ((int)Objects.Length < Object_Number * 2)
            {
                Array.Resize(ref Objects, Object_Number * 2 + 1);
                Print("Objects.Length after {0}", Objects.Length);
            }
            Objects[Object_Number * 2 - 1] = "Line" + Level + First_Point;
            Objects[Object_Number * 2] = "Text" + Level + First_Point;
            */
 
        private double Fibo_Level(double Base_Point, double Target_Point, double Level)
        {
            return Math.Round(Base_Point > Target_Point ? (Base_Point - (Base_Point - Target_Point) * Level) : (Base_Point + (Target_Point - Base_Point) * Level), 5);
        }
 
 
        public override void Calculate(int index)
        {
            double low = MarketSeries.Low[index];
            double high = MarketSeries.High[index];
 
            if (Extremum_Price == 0.0)
            {
                Extremum_Price = high;
                Extremum_Price_Up = high;
                Extremum_Price_Down = low;
            }
 
            if (MarketSeries.Close.Count < 2)
                return;
 
            if (direction == Direction.Down)
            {
                if (low <= Extremum_Price)
                    Move_Extremum(index, low);
                else if (high >= Extremum_Price * (1.0 + deviationPercent * 0.01))
                {
                    Set_Extremum(index, high);
                    direction = Direction.Up;
                }
            }
            else
            {
                if (high >= Extremum_Price)
                    Move_Extremum(index, high);
                else if (low <= Extremum_Price * (1.0 - deviationPercent * 0.01))
                {
                    Set_Extremum(index, low);
                    direction = Direction.Down;
                }
            }
        }
    }
}

 

İndikator kategorisinde (14 puan) tarafından | 114 kez görüntülendi

1 cevap

0 beğenilme 0 beğenilmeme

Merhaba,

Çok kompleks ve farklı platformlara ait kodlamaları maalesef IQ'ya dönüştürülmesi noktasında yardımcı olamıyoruz.

Muhtemelen görmüşsünüzdür hazır indikatörler içerisinde Zigzag indikatörü bulunmaktadır.

Zigzag repaint yapan bir indikatör olduğundan stratejide kullanılması sağlıklı olmayabilir.

İyi çalışmalar

(6,848 puan) tarafından
Hoş geldiniz, Matriks Destek Platformu sizlere sorularınızın hızlıca cevaplanması için bir ortam sağlar. Sorduğunuz ve cevapladığınız soruların ve yorumlarınızın aldığı oylar üzerinden puan kazanırsınız. Puan sistemine bağlı kampanyamızla ücretsiz kullanım avantajlarından faydalanabilirsiniz.



4,024 soru
3,976 cevap
2,805 yorum
2,974 kullanıcı