Discussion de l'article "Les méthodes de William Gann (première partie) : Création de l'indicateur Angles de Gann" - page 2

[Bogard_11]

Vitaly Muzichenko #:

Si vous avez suivi un cours et que cela n'a pas marché - et cela ne marchera pas, ce qui est logique - on vous dira que vous ne comparez pas correctement les étoiles entre les planètes.

Vous ne comprenez pas ce qui se passe : celui qui a compris comment Gunn négociait n'enseignera rien à personne. C'est pourquoi tous les cours dispensés par des gitans de l'information sont complètement faux.

[Антон Данилов]

Bogard_11 #:

La personne qui a découvert comment Gunn a échangé des informations n'enseignera rien à personne. C'est pourquoi tous les cours dispensés par des gitans de l'information ne sont rien d'autre que de la poudre aux yeux.

Vous dites la vérité, mon cher :-)

[Eva-oren]

Gunn était un brillant commerçant, astrologue et numérologue, un mathématicien qui croyait aux nombres magiques. Un grand devin qui a prédit le début et la fin de la Première et de la Seconde Guerre mondiale. Il a eu un grand nombre d'étudiants, mais, comme le prétendent ses disciples, il ne donnait sa stratégie à personne. Il a brassé énormément d'argent et, à la fin de sa vie, il ne disposait que de la modeste somme de 100 000 dollars. J'attends avec impatience les prochains articles sur la personnalité géniale de Gunn, très intéressants.

[Bogard_11]

Eva-oren #:
Gunn était un brillant commerçant, astrologue et numérologue, un mathématicien qui croyait aux nombres magiques. Un grand devin qui a prédit le début et la fin de la Première et de la Seconde Guerre mondiale. Il a eu un grand nombre d'étudiants, mais, comme le prétendent ses disciples, il ne donnait sa stratégie à personne. Il a brassé énormément d'argent et, à la fin de sa vie, il ne disposait que de la modeste somme de 100 000 dollars. J'attends avec impatience les prochains articles sur la personnalité géniale de Gunn, c'est très intéressant.

J'ai oublié de mentionner qu'il avait un jet privé, ce qui était rare à l'époque. Plus 100 000 $ à l'époque, c'est au moins un multiple de vert aujourd'hui, si ce n'est 10 multiples.

P.S. - Il a transmis la stratégie. Dans ses écrits. Qui le voulait, rassemblés à partir de différents chapitres du TC complet. Gunn a tout dispersé pour que personne ne puisse l'obtenir gratuitement.

[Ivan Butko]

J'ai trouvé un moyen de faire du commerce sur Google

[Maxim Kuznetsov]

Ivan Butko #:
J'ai trouvé un moyen de négocier sur Google

dans la deuxième image - je ne comprends pas le principe :-(

[Bogard_11]

Je vais vous donner une image. Celui qui comprend Gunn comprendra immédiatement le principe du travail dans les virages, où chercher une longue entrée et où rouler.

[Avatar2025]

Avertissement : je ne connais pas la syntaxe de programmation MQL5 pour les indicateurs.

Mais je pense que l'algorithme de la ligne d'angle n'est pas correct (voir l'indicateur de ligne d'angle ci-joint que j'ai écrit dans un autre logiciel), voici mon dialogue avec 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;

Cependant, DeepSeek m'a donné un code de modification qui ne semblait pas fonctionner pour moi :

//+------------------------------------------------------------------+
//| Tracer la ligne de l'éventail de Venn & nbsp; |
//+------------------------------------------------------------------+
void DrawGannFan(double extremum, datetime extremumTime)
{
    // Définir l'angle de Gann et le nom correspondant.
    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"};

    // Obtenir le nombre de périodes depuis le point extrême jusqu'à la ligne K actuelle
    int extremumBar = iBarShift(_Symbol, PERIOD_CURRENT, extremumTime);
    int currentBar = 0; // La ligne K actuelle est 0
    int barDiff = currentBar - extremumBar; // Différence de numéro de cycle
    
    // Calculer la différence de hauteur de prix
    double priceDiff;
    if(isTrendUp)
    {
        // Tendance haussière : calcule la hauteur entre le plus bas extrême et le prix maximum actuel.
        double currentHigh = iHigh(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = currentHigh - extremum;
    }
    else
    {
        // Tendance baissière : calcule la hauteur entre le plus haut extrême et le plus bas prix actuel
        double currentLow = iLow(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = extremum - currentLow;
    }
    
    // Calculer la pente de base (pente de la ligne 1x1)
    double baseSlope = (barDiff > 0) ? priceDiff / barDiff : 0;
    
    // Tracer des lignes de secteur pour chaque angle
    for(int i = 0; i < ArraySize(angles); i++)
    {
        string label = "GannFan_" + angleNames[i];  // Étiquettes d'objets
        double angle = angles[i];                  // Angle actuel
        
        // Calculer le multiplicateur de pente en fonction de l'angle
        double slopeMultiplier = MathTan(angle * M_PI / 180.0) / MathTan(45 * M_PI / 180.0);
        
        // Calcul du décalage de prix (basé sur la pente sous-jacente et le multiplicateur d'angle)
        double priceShift = baseSlope * barDiff * slopeMultiplier * _Point;
        double endPrice;
        
        // Calcul du prix de clôture en fonction de la direction de la tendance
        if(isTrendUp)
        {
            endPrice = extremum + priceShift;
        }
        else
        {
            endPrice = extremum - priceShift;
            angle = -angle; // Angle de renversement dans une tendance baissière
        }

        // Créer un objet ligne de tendance
        if(ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, TimeCurrent(), endPrice))
        {
            // Définir les propriétés de la ligne de tendance
            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());
        }
    }
}

//+------------------------------------------------------------------+
//|| Tracé d'une ligne de Gann inversée en éventail & nbsp ; &nbsp ; ||
//+------------------------------------------------------------------+
void DrawOppositeGannFan(double extremum, datetime extremumTime)
{
    // Définir l'angle de Gann et le nom correspondant.
    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"};

    // Obtenir le nombre de périodes depuis le point extrême jusqu'à la ligne K actuelle
    int extremumBar = iBarShift(_Symbol, PERIOD_CURRENT, extremumTime);
    int currentBar = 0; // La ligne K actuelle est 0
    int barDiff = currentBar - extremumBar; // Différence de numéro de cycle
    
    // Calculer la différence de hauteur de prix
    double priceDiff;
    if(!isTrendUp)
    {
        // Tendance inverse (vers le haut) : calcule la hauteur entre l'extrême bas et le prix maximum actuel.
        double currentHigh = iHigh(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = currentHigh - extremum;
    }
    else
    {
        // Tendance inverse (à la baisse) : calcule la hauteur entre le prix le plus haut et le prix le plus bas actuel.
        double currentLow = iLow(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = extremum - currentLow;
    }
    
    // Calculer la pente de base (pente de la ligne 1x1)
    double baseSlope = (barDiff > 0) ? priceDiff / barDiff : 0;
    
    // Tracer des lignes de secteur pour chaque angle
    for(int i = 0; i < ArraySize(angles); i++)
    {
        string label = "OppositeGannFan_" + angleNames[i];  // Étiquettes d'objets
        double angle = angles[i];                          // Angle actuel
        
        // Calculer le multiplicateur de pente en fonction de l'angle
        double slopeMultiplier = MathTan(angle * M_PI / 180.0) / MathTan(45 * M_PI / 180.0);
        
        // Calcul du décalage de prix (basé sur la pente sous-jacente et le multiplicateur d'angle)
        double priceShift = baseSlope * barDiff * slopeMultiplier * _Point;
        double endPrice;
        
        // Calcul du prix de clôture en fonction de la direction de la tendance inverse
        if(!isTrendUp)
        {
            endPrice = extremum + priceShift;
        }
        else
        {
            endPrice = extremum - priceShift;
            angle = -angle; // Angle de renversement dans une tendance baissière
        }

        // Créer un objet ligne de tendance
        if(ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, TimeCurrent(), endPrice))
        {
            // Définir les propriétés de la ligne de tendance
            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());
        }
    }
}

Finalement, j'ai dû demander à DeepSeek de modifier votre code source (il fonctionne bien et trace des lignes automatiquement) :

#property copyright "Copyright 2024, Evgeniy Shtenco"  // Informations sur les droits d'auteur
#property link      "https://www.mql5.com/en/users/koshtenko"  // Liens d'auteur
#property version   "1.00"  // Numéro de version de l'indicateur
#property indicator_chart_window  // Les indicateurs sont affichés dans la fenêtre du graphique

// Paramètres d'entrée
input int LookBackBars = 300;      // Nombre de lignes K analysées retour
input color GannFanColor = clrBlue; // Les couleurs de la ligne de supporters de Vaughan

// Variables globales
double extremumPrice;        // Prix du point extrême
datetime extremumTime;       // Temps de point extrême
double oppositeExtremumPrice; // Prix du point extrême inversé
datetime oppositeExtremumTime; // Temps du point d'inversion de polarité
bool isTrendUp;              // Drapeau de direction de la tendance (vrai pour une tendance haussière)

//+------------------------------------------------------------------+
//| Fonctions d'initialisation des indicateurs personnalisés & nbsp ; &nbsp ; ||
//+------------------------------------------------------------------+
int OnInit()
{
    return (INIT_SUCCEEDED);  // Initialisation réussie
}

//+------------------------------------------------------------------+
//| Fonctions de réinitialisation des indicateurs personnalisés & nbsp ; &nbsp ; ||
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
    {
        // Supprimer tous les objets du secteur Gann
        ObjectsDeleteAll(0, "GannFan_");
ObjectsDeleteAll(0, "OppositeGannFan_");
}

//+------------------------------------------------------------------+
//| Fonctions de calcul de l'indicateur personnalisé & nbsp ; &nbsp ; | | | | | | | |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,          // Nombre actuel de cycles
const int prev_calculated,      // Nombre de cycles calculés précédemment
const datetime & time[],         // Tableaux temporels
                const double & open[],          // Tableau des prix d'ouverture
                const double & high[],           // Tableau des prix les plus élevés
                const double & low[],            // Tableau des prix les plus bas
                const double & close[],         // Tableau des cours de clôture
                const long & tick_volume[],      // Tableau des volumes
                const long & volume[],           // Tableau des volumes réels
                const int & spread[])            // Tableau des écarts de points
{
    if (rates_total < LookBackBars) return (0);  // Retour s'il n'y a pas assez de données

    // Effacer les objets dessinés précédemment
    if (prev_calculated == 0) {
        ObjectsDeleteAll(0, "GannFan_");
        ObjectsDeleteAll(0, "OppositeGannFan_");
    }

    // Recherche des points extrêmes dans les 300 dernières lignes K
    FindExtremums(rates_total, high, low, time);

    // Tracer la ligne de l'éventail de Venn
    DrawGannFan(extremumPrice, extremumTime);
    DrawOppositeGannFan(oppositeExtremumPrice, oppositeExtremumTime);

    return (rates_total);  // Renvoie le nombre total de colonnes traitées
}

//+------------------------------------------------------------------+
//| Trouver les points extrêmes à l'intérieur d'un nombre spécifié de lignes K. |
//+------------------------------------------------------------------+
void FindExtremums(const int rates_total, const double & high[], const double & low[], const datetime & time[])
{
    int startIndex = rates_total - LookBackBars;  // Début de l'indexation (il y a 300 K-lignes)
    int endIndex = rates_total - 1;               // Index de fin (dernière ligne K)

    // Trouver des hauts et des bas
    int highestIndex = ArrayMaximum(high, startIndex, LookBackBars);
    int lowestIndex = ArrayMinimum(low, startIndex, LookBackBars);

    // Déterminer la direction de la tendance (comparer le moment des hauts et des bas)
    if (time[highestIndex] > time[lowestIndex]) {
        // Tendance baissière si le point le plus haut se situe après le point le plus bas
        extremumPrice = high[highestIndex];
        extremumTime = time[highestIndex];
        oppositeExtremumPrice = low[lowestIndex];
        oppositeExtremumTime = time[lowestIndex];
        isTrendUp = false;
    }
    else {
        // sinon tendance haussière
        extremumPrice = low[lowestIndex];
        extremumTime = time[lowestIndex];
        oppositeExtremumPrice = high[highestIndex];
        oppositeExtremumTime = time[highestIndex];
        isTrendUp = true;
    }
}

//+------------------------------------------------------------------+
//| Tracer la ligne de l'éventail de Venn & nbsp; |
//+------------------------------------------------------------------+
void DrawGannFan(double extremum, datetime extremumTime)
{
    // Définir l'angle de Gann et le nom correspondant.
    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"};

    // Calculer le temps de fin de la ligne de secteur (temps actuel + 300 cycles)
    datetime endTime = TimeCurrent();  // Utiliser l'heure actuelle comme heure de fin

    // Tracer des lignes de secteur pour chaque angle
    for (int i = 0; i < ArraySize(angles); i++)
    {
        string label = "GannFan_" + angleNames[i];  // Étiquettes d'objets
        double angle = angles[i];                  // Angle actuel

        // Calculer le décalage de prix (basé sur le décalage horaire)
        double secondsDiff = endTime - extremumTime;
        double priceShift = MathTan(angle * M_PI / 180.0) * secondsDiff / PeriodSeconds();
        double endPrice;

        // Calcul du prix de clôture en fonction de la direction de la tendance
        if (isTrendUp) {
            endPrice = extremum + priceShift;
        }
        else {
            endPrice = extremum - priceShift;
            angle = -angle; // Angle de renversement dans une tendance baissière
        }

        // Créer un objet ligne de tendance
        if (ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, endTime, endPrice)) {
            // Définir les propriétés de la ligne de tendance
            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());
        }
    }
}

//+------------------------------------------------------------------+
//|| Tracé d'une ligne de Gann inversée en éventail & nbsp ; &nbsp ; ||
//+------------------------------------------------------------------+
void DrawOppositeGannFan(double extremum, datetime extremumTime)
{
    // Définir l'angle de Gann et le nom correspondant.
    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"};

    // Calculer l'heure de fin de la ligne de secteur (heure actuelle)
    datetime endTime = TimeCurrent();

    // Tracer des lignes de secteur pour chaque angle
    for (int i = 0; i < ArraySize(angles); i++)
    {
        string label = "OppositeGannFan_" + angleNames[i];  // Étiquettes d'objets
        double angle = angles[i];                          // Angle actuel

        // Calculer le décalage de prix (basé sur le décalage horaire)
        double secondsDiff = endTime - extremumTime;
        double priceShift = MathTan(angle * M_PI / 180.0) * secondsDiff / PeriodSeconds();
        double endPrice;

        // Calcul du prix final en fonction de la direction de la tendance opposée
        if (!isTrendUp) // Inverser la tendance
        {
            endPrice = extremum + priceShift;
        }
        else {
            endPrice = extremum - priceShift;
            angle = -angle; // Angle de renversement dans une tendance baissière
        }

        // Créer un objet ligne de tendance
        if (ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, endTime, endPrice)) {
            // Définir les propriétés de la ligne de tendance
            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());
        }
    }
}

//+------------------------------------------------------------------+
//| Fonctions de gestion des événements graphiques &nbsp nbsp ; & & nbsp ; |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,                  // ID de l'événement
const long & lparam,            // Paramètres entiers longs
                  const double & dparam,          // Paramètres de double précision
                  const string & sparam)         // Paramètres de la chaîne de caractères
{
    // Redessiner les objets lorsque le graphique change
    if (id == CHARTEVENT_CHART_CHANGE || id == CHARTEVENT_CLICK) {
        // Retrouvez les extrêmes et tracez la ligne de l'éventail de Venn.
        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);
    }
}