Diskussion zum Artikel "Methoden von William Gann (Teil I): Erstellen des Gann Angles-Indikators" - Seite 2

Neuer Kommentar
 
Vitaly Muzichenko #:

Wenn Sie einen Kurs belegt haben und es nicht geklappt hat - und es wird nicht klappen, was logisch ist - wird man Ihnen sagen, dass Sie die Sterne nicht richtig zwischen den Planeten vergleichen.

Wer herausgefunden hat, wie Gunn gehandelt hat, wird es niemandem beibringen. Deshalb sind alle Kurse von Informationszigeunern eine komplette Fälschung.

 
Bogard_11 #:

Wer auch immer herausgefunden hat, wie Gunn gehandelt hat, wird es niemandem beibringen. Deshalb sind all die Kurse von Informationszigeunern nichts als Schwindel.

Du sagst die Wahrheit, Liebes :-)
 
Gunn war ein brillanter Händler, Astrologe und Numerologe, ein Mathematiker, der an magische Zahlen glaubte. Ein großer Wahrsager, der den Beginn und das Ende des Ersten und Zweiten Weltkriegs vorhersagte. Er hatte eine große Anzahl von Schülern, aber wie seine Anhänger behaupten, gab er seine Strategie an niemanden weiter. Er hatte einen riesigen Geldumsatz und kam am Ende seines Lebens auf eine bescheidene Summe von 100000 Dollar. Ich freue mich schon auf die nächsten Artikel über Gunns geniale Persönlichkeit, sehr interessant.
 
Eva-oren #:
Gunn war ein brillanter Händler, Astrologe und Numerologe, ein Mathematiker, der an magische Zahlen glaubte. Ein großer Wahrsager, der den Beginn und das Ende des Ersten und Zweiten Weltkriegs vorhersagte. Er hatte eine große Anzahl von Schülern, aber wie seine Anhänger behaupten, gab er seine Strategie an niemanden weiter. Er hatte einen riesigen Geldumsatz und kam am Ende seines Lebens auf eine bescheidene Summe von 100000 Dollar. Ich freue mich schon auf die nächsten Artikel über Gunns geniale Persönlichkeit, sehr interessant.

Ich vergaß zu erwähnen, dass er einen Privatjet hatte, was damals eine Seltenheit war. Und 100.000 Dollar damals, das ist heute mindestens ein Vielfaches davon, wenn nicht 10 Vielfache.

P.S. - er hat die Strategie weitergegeben. In seinen Schriften. Wer wollte, sammelte aus verschiedenen Kapiteln des kompletten TC. Gunn hat alles verstreut, damit niemand es umsonst bekommen konnte.

 
Eine Möglichkeit gefunden, über Google zu handeln

 
Ivan Butko #:
Ich habe eine Möglichkeit gefunden, auf Google zu handeln

im zweiten Bild - ich verstehe das Prinzip nicht :-(

 

Ich werde Ihnen ein Bild geben. Wer Gunn versteht, versteht sofort das Prinzip der Arbeit mit Ecken, wo man einen langen Einstieg sucht und wo man sich überschlagen kann.


 
Disclaimer: Ich weiß nicht, MQL5 Programmierung Syntax für Indikatoren.

Aber ich denke, dass der Winkellinien-Algorithmus nicht richtig ist (siehe beigefügten Winkellinien-Indikator, den ich in einer anderen Software geschrieben habe), hier ist mein Dialog mit DeepSeek:

下面代码是通达信的代码，里面计算斜率的方法才是正确的，请阅读理解后，把上面priceShift 的计算方法改为下列代码正确的范式:

涨周期数:= IF(低点k位置 > 高点k位置, 低点k位置 - 高点k位置 + 1, 低点k位置), NODRAW;
跌周期数:= IF(高点k位置 > 低点k位置, 高点k位置 - 低点k位置 + 1, 高点k位置), NODRAW;

天线:= CONST(IF(高点k位置 = 1, H, REF(H, 高点k位置 - 1))), NODRAW;
地线:= CONST(IF(低点k位置 = 1, L, REF(L, 低点k位置 - 1))), NODRAW;

上涨天数:= IF(ISVALID(地线), BARSLAST(L = 地线), DRAWNULL), NODRAW;
下跌天数:= IF(ISVALID(天线), BARSLAST(H = 天线), DRAWNULL), NODRAW;

上涨高度:= IF(低点k位置 > 高点k位置, 天线 - 地线, HHV(H, 上涨天数) - 地线), NODRAW;
下跌高度:= IF(高点k位置 > 低点k位置, 天线 - 地线, 天线 - LLV(L, 下跌天数)), NODRAW;

上涨斜率:= IF(上涨天数 > 0, ROUND2(上涨高度 / 涨周期数, 4), 0), NODRAW;
下跌斜率:= IF(下跌天数 > 0, ROUND2(下跌高度 / 跌周期数, 4), 0), NODRAW;

DeepSeek gab mir jedoch einen Änderungscode, der bei mir nicht zu funktionieren schien: 
//+------------------------------------------------------------------+
//| Einzeichnen der Venn-Sektorlinie & nbsp; |
//+------------------------------------------------------------------+
void DrawGannFan(double extremum, datetime extremumTime)
{
    // Definieren Sie den Gann-Winkel und den entsprechenden Namen.
    double angles[] = {82.5, 75, 71.25, 63.75, 45, 26.25, 18.75, 15, 7.5};
    string angleNames[] = {"1x8", "1x4", "1x3", "1x2", "1x1", "2x1", "3x1", "4x1", "8x1"};

    // Ermittelt die Anzahl der Perioden vom Extrempunkt bis zur aktuellen K-Linie
    int extremumBar = iBarShift(_Symbol, PERIOD_CURRENT, extremumTime);
    int currentBar = 0; // Aktuelle K-Linie ist 0
    int barDiff = currentBar - extremumBar; // Differenz der Zyklusnummern
    
    // Berechnen Sie die Preishöhendifferenz
    double priceDiff;
    if(isTrendUp)
    {
        // Aufwärtstrend: Berechnet die Höhe vom extremen Tiefstkurs bis zum aktuellen Höchstkurs
        double currentHigh = iHigh(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = currentHigh - extremum;
    }
    else
    {
        // Abwärtstrend: Berechnet die Höhe vom extremen Hoch bis zum aktuellen Tiefstkurs
        double currentLow = iLow(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = extremum - currentLow;
    }
    
    // Berechnen Sie die Basisneigung (Steigung der 1x1-Linie)
    double baseSlope = (barDiff > 0) ? priceDiff / barDiff : 0;
    
    // Zeichnen Sie Sektorenlinien für jeden Winkel
    for(int i = 0; i < ArraySize(angles); i++)
    {
        string label = "GannFan_" + angleNames[i];  // Objektbeschriftungen
        double angle = angles[i];                  // Aktueller Winkel
        
        // Berechnung des Neigungsmultiplikators auf der Grundlage des Winkels
        double slopeMultiplier = MathTan(angle * M_PI / 180.0) / MathTan(45 * M_PI / 180.0);
        
        // Berechnung des Preisausgleichs (basierend auf der zugrunde liegenden Neigung und dem Winkelmultiplikator)
        double priceShift = baseSlope * barDiff * slopeMultiplier * _Point;
        double endPrice;
        
        // Berechnung des Schlusskurses auf der Grundlage der Trendrichtung
        if(isTrendUp)
        {
            endPrice = extremum + priceShift;
        }
        else
        {
            endPrice = extremum - priceShift;
            angle = -angle; // Umkehrwinkel im Abwärtstrend
        }

        // Erstellen eines Trendlinienobjekts
        if(ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, TimeCurrent(), endPrice))
        {
            // Eigenschaften der Trendlinie festlegen
            ObjectSetInteger(0, label, OBJPROP_COLOR, GannFanColor);
            ObjectSetInteger(0, label, OBJPROP_STYLE, STYLE_SOLID);
            ObjectSetInteger(0, label, OBJPROP_WIDTH, 1);
            ObjectSetInteger(0, label, OBJPROP_RAY_RIGHT, true);
            ObjectSetString(0, label, OBJPROP_TOOLTIP, "Gann Fan " + angleNames[i]);
        }
        else
        {
            Print("Failed to create Gann Fan line: ", GetLastError());
        }
    }
}

//+------------------------------------------------------------------+
//|| Plotten einer umgekehrten Gann-Fächerlinie & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void DrawOppositeGannFan(double extremum, datetime extremumTime)
{
    // Definieren Sie den Gann-Winkel und den entsprechenden Namen.
    double angles[] = {82.5, 75, 71.25, 63.75, 45, 26.25, 18.75, 15, 7.5};
    string angleNames[] = {"1x8", "1x4", "1x3", "1x2", "1x1", "2x1", "3x1", "4x1", "8x1"};

    // Ermittelt die Anzahl der Perioden vom Extrempunkt bis zur aktuellen K-Linie
    int extremumBar = iBarShift(_Symbol, PERIOD_CURRENT, extremumTime);
    int currentBar = 0; // Aktuelle K-Linie ist 0
    int barDiff = currentBar - extremumBar; // Differenz der Zyklusnummern
    
    // Berechnen Sie die Preishöhendifferenz
    double priceDiff;
    if(!isTrendUp)
    {
        // Umgekehrter Trend (aufwärts): Berechnet die Höhe vom extremen Tiefstkurs bis zum aktuellen Höchstkurs
        double currentHigh = iHigh(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = currentHigh - extremum;
    }
    else
    {
        // Umgekehrter Trend (abwärts): Berechnet die Höhe vom extremen Hoch zum aktuellen Tiefstkurs
        double currentLow = iLow(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = extremum - currentLow;
    }
    
    // Berechnen Sie die Basisneigung (Steigung der 1x1-Linie)
    double baseSlope = (barDiff > 0) ? priceDiff / barDiff : 0;
    
    // Zeichnen Sie Sektorenlinien für jeden Winkel
    for(int i = 0; i < ArraySize(angles); i++)
    {
        string label = "OppositeGannFan_" + angleNames[i];  // Objektbeschriftungen
        double angle = angles[i];                          // Aktueller Winkel
        
        // Berechnung des Neigungsmultiplikators auf der Grundlage des Winkels
        double slopeMultiplier = MathTan(angle * M_PI / 180.0) / MathTan(45 * M_PI / 180.0);
        
        // Berechnung des Preisausgleichs (basierend auf der zugrunde liegenden Neigung und dem Winkelmultiplikator)
        double priceShift = baseSlope * barDiff * slopeMultiplier * _Point;
        double endPrice;
        
        // Berechnung des Schlusskurses auf der Grundlage der Richtung des umgekehrten Trends
        if(!isTrendUp)
        {
            endPrice = extremum + priceShift;
        }
        else
        {
            endPrice = extremum - priceShift;
            angle = -angle; // Umkehrwinkel im Abwärtstrend
        }

        // Erstellen eines Trendlinienobjekts
        if(ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, TimeCurrent(), endPrice))
        {
            // Eigenschaften der Trendlinie festlegen
            ObjectSetInteger(0, label, OBJPROP_COLOR, GannFanColor);
            ObjectSetInteger(0, label, OBJPROP_STYLE, STYLE_SOLID);
            ObjectSetInteger(0, label, OBJPROP_WIDTH, 1);
            ObjectSetInteger(0, label, OBJPROP_RAY_RIGHT, true);
            ObjectSetString(0, label, OBJPROP_TOOLTIP, "Opposite Gann Fan " + angleNames[i]);
        }
        else
        {
            Print("Failed to create Opposite Gann Fan line: ", GetLastError());
        }
    }
}





Schließlich musste ich DeepSeek bitten, Ihren Quellcode zu ändern (er funktioniert gut und zeichnet automatisch Linien): 
#property copyright "Copyright 2024, Evgeniy Shtenco"  // Urheberrechtsinformationen
#property link      "https://www.mql5.com/en/users/koshtenko"  // Autorenlinks
#property version   "1.00"  // Versionsnummer des Indikators
#property indicator_chart_window  // Indikatoren werden im Diagrammfenster angezeigt

// Eingabeparameter
input int LookBackBars = 300;      // Anzahl der analysierten K-Linien zurück
input color GannFanColor = clrBlue; // Die Farben der Fanlinie von Vaughan

// Globale Variablen
double extremumPrice;        // Extremer Punktpreis
datetime extremumTime;       // Extremzeitpunkt
double oppositeExtremumPrice; // Umgekehrter Extrempunktpreis
datetime oppositeExtremumTime; // Umkehrung der Polarität Punkt Zeit
bool isTrendUp;              // Trendrichtungsflagge (wahr für Aufwärtstrend)

//+------------------------------------------------------------------+
//| Benutzerdefinierte Indikatorinitialisierungsfunktionen &. nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
int OnInit()
{
    return (INIT_SUCCEEDED);  // Erfolgreiche Initialisierung
}

//+------------------------------------------------------------------+
//| Benutzerdefinierte Funktionen zur Reinitialisierung von Indikatoren & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
    {
        // Alle Gann-Sektorobjekte löschen
        ObjectsDeleteAll(0, "GannFan_");
ObjectsDeleteAll(0, "OppositeGannFan_");
}

//+------------------------------------------------------------------+
//| Benutzerdefinierte Indikatorberechnungsfunktionen &. nbsp; &nbsp ; | | | | | | | |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,          // Aktuelle Anzahl der Zyklen
const int prev_calculated,      // Anzahl der zuvor berechneten Zyklen
const datetime & time[],         // Zeit-Arrays
                const double & open[],          // Array der Eröffnungspreise
                const double & high[],           // Array der höchsten Preise
                const double & low[],            // Array der niedrigsten Preise
                const double & close[],         // Schlusskurs-Array
                const long & tick_volume[],      // Volumen-Array
                const long & volume[],           // Reales Volumen-Array
                const int & spread[])            // Array der Punktespannen
{
    if (rates_total < LookBackBars) return (0);  // Rückgabe, wenn nicht genügend Daten vorhanden sind

    // Löschen Sie die zuvor gezeichneten Objekte
    if (prev_calculated == 0) {
        ObjectsDeleteAll(0, "GannFan_");
        ObjectsDeleteAll(0, "OppositeGannFan_");
    }

    // Suche nach den Extrempunkten in den letzten 300 K-Linien
    FindExtremums(rates_total, high, low, time);

    // Zeichnen der Venn-Fächerlinie
    DrawGannFan(extremumPrice, extremumTime);
    DrawOppositeGannFan(oppositeExtremumPrice, oppositeExtremumTime);

    return (rates_total);  // Gibt die Gesamtzahl der verarbeiteten Spalten zurück
}

//+------------------------------------------------------------------+
//| Suche nach Extrempunkten innerhalb einer bestimmten Anzahl von K-Linien. |
//+------------------------------------------------------------------+
void FindExtremums(const int rates_total, const double & high[], const double & low[], const datetime & time[])
{
    int startIndex = rates_total - LookBackBars;  // Beginn der Indizierung (vor 300 K-Zeilen)
    int endIndex = rates_total - 1;               // Endindex (letzte K-Zeile)

    // Hochs und Tiefs finden
    int highestIndex = ArrayMaximum(high, startIndex, LookBackBars);
    int lowestIndex = ArrayMinimum(low, startIndex, LookBackBars);

    // Bestimmen Sie die Trendrichtung (vergleichen Sie das Timing von Höchst- und Tiefstwerten)
    if (time[highestIndex] > time[lowestIndex]) {
        // Abwärtstrend, wenn der höchste Punkt nach dem niedrigsten Punkt liegt
        extremumPrice = high[highestIndex];
        extremumTime = time[highestIndex];
        oppositeExtremumPrice = low[lowestIndex];
        oppositeExtremumTime = time[lowestIndex];
        isTrendUp = false;
    }
    else {
        // sonst Aufwärtstrend
        extremumPrice = low[lowestIndex];
        extremumTime = time[lowestIndex];
        oppositeExtremumPrice = high[highestIndex];
        oppositeExtremumTime = time[highestIndex];
        isTrendUp = true;
    }
}

//+------------------------------------------------------------------+
//| Einzeichnen der Venn-Sektorlinie & nbsp; |
//+------------------------------------------------------------------+
void DrawGannFan(double extremum, datetime extremumTime)
{
    // Definieren Sie den Gann-Winkel und den entsprechenden Namen.
    double angles[] = { 82.5, 75, 71.25, 63.75, 45, 26.25, 18.75, 15, 7.5};
    string angleNames[] = { "1x8", "1x4", "1x3", "1x2", "1x1", "2x1", "3x1", "4x1", "8x1"};

    // Berechnung der Endzeit der Sektorzeile (aktuelle Zeit + 300 Zyklen)
    datetime endTime = TimeCurrent();  // Verwenden Sie die aktuelle Uhrzeit als Endzeitpunkt

    // Zeichnen Sie Sektorenlinien für jeden Winkel
    for (int i = 0; i < ArraySize(angles); i++)
    {
        string label = "GannFan_" + angleNames[i];  // Objektbeschriftungen
        double angle = angles[i];                  // Aktueller Winkel

        // Berechnung des Preisausgleichs (auf der Grundlage der Zeitdifferenz)
        double secondsDiff = endTime - extremumTime;
        double priceShift = MathTan(angle * M_PI / 180.0) * secondsDiff / PeriodSeconds();
        double endPrice;

        // Berechnung des Schlusskurses auf der Grundlage der Trendrichtung
        if (isTrendUp) {
            endPrice = extremum + priceShift;
        }
        else {
            endPrice = extremum - priceShift;
            angle = -angle; // Umkehrwinkel im Abwärtstrend
        }

        // Erstellen eines Trendlinienobjekts
        if (ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, endTime, endPrice)) {
            // Eigenschaften der Trendlinie festlegen
            ObjectSetInteger(0, label, OBJPROP_COLOR, GannFanColor);
            ObjectSetInteger(0, label, OBJPROP_STYLE, STYLE_SOLID);
            ObjectSetInteger(0, label, OBJPROP_WIDTH, 1);
            ObjectSetInteger(0, label, OBJPROP_RAY_RIGHT, true);
            ObjectSetString(0, label, OBJPROP_TOOLTIP, "Gann Fan " + angleNames[i]);
        }
        else {
            Print("Failed to create Gann Fan line: ", GetLastError());
        }
    }
}

//+------------------------------------------------------------------+
//|| Plotten einer umgekehrten Gann-Fächerlinie & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void DrawOppositeGannFan(double extremum, datetime extremumTime)
{
    // Definieren Sie den Gann-Winkel und den entsprechenden Namen.
    double angles[] = { 82.5, 75, 71.25, 63.75, 45, 26.25, 18.75, 15, 7.5};
    string angleNames[] = { "1x8", "1x4", "1x3", "1x2", "1x1", "2x1", "3x1", "4x1", "8x1"};

    // Berechnung der Endzeit der Sektorzeile (aktuelle Zeit)
    datetime endTime = TimeCurrent();

    // Zeichnen Sie Sektorenlinien für jeden Winkel
    for (int i = 0; i < ArraySize(angles); i++)
    {
        string label = "OppositeGannFan_" + angleNames[i];  // Objektbeschriftungen
        double angle = angles[i];                          // Aktueller Winkel

        // Berechnung des Preisausgleichs (auf der Grundlage der Zeitdifferenz)
        double secondsDiff = endTime - extremumTime;
        double priceShift = MathTan(angle * M_PI / 180.0) * secondsDiff / PeriodSeconds();
        double endPrice;

        // Berechnung des Endpreises auf der Grundlage der Richtung des entgegengesetzten Trends
        if (!isTrendUp) // Umgekehrter Trend
        {
            endPrice = extremum + priceShift;
        }
        else {
            endPrice = extremum - priceShift;
            angle = -angle; // Umkehrwinkel im Abwärtstrend
        }

        // Erstellen eines Trendlinienobjekts
        if (ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, endTime, endPrice)) {
            // Eigenschaften der Trendlinie festlegen
            ObjectSetInteger(0, label, OBJPROP_COLOR, GannFanColor);
            ObjectSetInteger(0, label, OBJPROP_STYLE, STYLE_SOLID);
            ObjectSetInteger(0, label, OBJPROP_WIDTH, 1);
            ObjectSetInteger(0, label, OBJPROP_RAY_RIGHT, true);
            ObjectSetString(0, label, OBJPROP_TOOLTIP, "Opposite Gann Fan " + angleNames[i]);
        }
        else {
            Print("Failed to create Opposite Gann Fan line: ", GetLastError());
        }
    }
}

//+------------------------------------------------------------------+
//| Diagramm-Ereignishandlerfunktionen &nbsp nbsp; & & nbsp; |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,                  // Ereignis-ID
const long & lparam,            // Lange ganzzahlige Parameter
                  const double & dparam,          // Parameter mit doppelter Genauigkeit
                  const string & sparam)         // String-Parameter
{
    // Erneutes Zeichnen von Objekten, wenn sich das Diagramm ändert
    if (id == CHARTEVENT_CHART_CHANGE || id == CHARTEVENT_CLICK) {
        // Finden Sie die Extrema neu und zeichnen Sie die Venn-Fächerlinie.
        int rates_total = Bars(_Symbol, PERIOD_CURRENT);
        double high[], low[];
        datetime time[];
        ArraySetAsSeries(high, true);
        ArraySetAsSeries(low, true);
        ArraySetAsSeries(time, true);
        CopyHigh(_Symbol, PERIOD_CURRENT, 0, rates_total, high);
        CopyLow(_Symbol, PERIOD_CURRENT, 0, rates_total, low);
        CopyTime(_Symbol, PERIOD_CURRENT, 0, rates_total, time);

        FindExtremums(rates_total, high, low, time);
        DrawGannFan(extremumPrice, extremumTime);
        DrawOppositeGannFan(oppositeExtremumPrice, oppositeExtremumTime);
    }
}
Dateien:
5h_2025-06-25.jpg  290 kb
12
Neuer Kommentar