Discussione sull’articolo "I metodi di William Gann (Parte I): Creazione dell'indicatore Angoli di Gann" - pagina 2

Nuovo commento
 
Vitaly Muzichenko #:

Se avete seguito un corso e non ha funzionato - e non funzionerà, come è logico - vi verrà detto che non state confrontando correttamente le stelle tra i pianeti.

Chi ha capito come ha fatto il trading di Gunn, non insegnerà a nessuno. Ecco perché tutti i corsi degli zingari dell'informazione sono un vero e proprio falso.

 
Bogard_11 #:

Chiunque abbia capito come si fa il trading di Gunn non lo insegnerà a nessuno. Ecco perché tutti i corsi degli zingari dell'informazione non sono altro che falsi.

Stai dicendo la verità, caro :-)
 
Gunn era un brillante commerciante, astrologo e numerologo, un matematico che credeva nei numeri magici. Un grande indovino che ha previsto l'inizio e la fine della Prima e della Seconda Guerra Mondiale. Aveva un numero enorme di studenti, ma, come sostengono i suoi seguaci, non dava la sua strategia a nessuno. Aveva un enorme giro di denaro, e alla fine della sua vita arrivò con la modesta somma di 100.000 dollari. Attendo con ansia i prossimi articoli sulla personalità geniale di Gunn, molto interessanti.
 
Eva-oren #:
Gunn era un brillante commerciante, astrologo e numerologo, un matematico che credeva nei numeri magici. Un grande indovino che ha previsto l'inizio e la fine della Prima e della Seconda Guerra Mondiale. Aveva un numero enorme di studenti, ma, come sostengono i suoi seguaci, non dava la sua strategia a nessuno. Aveva un enorme giro di denaro, e alla fine della sua vita arrivò con la modesta somma di 100.000 dollari. Attendo con ansia i prossimi articoli sulla personalità geniale di Gunn, molto interessanti.

Ho dimenticato di dire che aveva un jet privato, una rarità a quei tempi. Più 100.000 dollari di allora, sono almeno un millesimo di verde oggi, se non 10 millesimi.

P.S. - ha trasmesso la strategia. Nei suoi scritti. Chi ha voluto, ha raccolto da diversi capitoli del TC completo. Gunn sparse il tutto in modo che nessuno potesse ottenerlo gratuitamente.

 
Trovato un modo per commerciare su google

 
Ivan Butko #:
Ho trovato un modo per fare trading su Google

nella seconda immagine - non capisco il principio :-(

 

Vi darò un'immagine. Chi capisce Gunn, comprenderà immediatamente il principio del lavoro con gli angoli, dove cercare un'entrata lunga e dove fare un roll over.


 
Disclaimer: non conosco la sintassi di programmazione MQL5 per gli indicatori.

Ma credo che l'algoritmo della linea d'angolo non sia corretto (vedere l'indicatore della linea d'angolo allegato che ho scritto in un altro software), ecco il mio dialogo con 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;

Tuttavia, DeepSeek mi ha dato un codice di modifica che non sembra funzionare per me: 
//+------------------------------------------------------------------+
//Tracciare la linea del ventaglio di Venn & nbsp; |
//+------------------------------------------------------------------+
void DrawGannFan(double extremum, datetime extremumTime)
{
    // Definire l'angolo di Gann e il nome corrispondente.
    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"};

    // Ottenere il numero di periodi dal punto estremo alla linea K corrente
    int extremumBar = iBarShift(_Symbol, PERIOD_CURRENT, extremumTime);
    int currentBar = 0; // La linea K corrente è 0
    int barDiff = currentBar - extremumBar; // Differenza del numero di ciclo
    
    // Calcolo della differenza di altezza del prezzo
    double priceDiff;
    if(isTrendUp)
    {
        // Uptrend: calcola l'altezza dal minimo estremo al prezzo massimo attuale
        double currentHigh = iHigh(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = currentHigh - extremum;
    }
    else
    {
        // Downtrend: calcola l'altezza dal massimo estremo al prezzo minimo attuale
        double currentLow = iLow(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = extremum - currentLow;
    }
    
    // Calcolo della pendenza di base (pendenza della linea 1x1)
    double baseSlope = (barDiff > 0) ? priceDiff / barDiff : 0;
    
    // Disegnare linee di settore per ogni angolo
    for(int i = 0; i < ArraySize(angles); i++)
    {
        string label = "GannFan_" + angleNames[i];  // Etichette degli oggetti
        double angle = angles[i];                  // Angolo corrente
        
        // Calcolare il moltiplicatore della pendenza in base all'angolo
        double slopeMultiplier = MathTan(angle * M_PI / 180.0) / MathTan(45 * M_PI / 180.0);
        
        // Calcolo dell'offset del prezzo (in base alla pendenza sottostante e al moltiplicatore dell'angolo)
        double priceShift = baseSlope * barDiff * slopeMultiplier * _Point;
        double endPrice;
        
        // Calcolo del prezzo di chiusura in base alla direzione del trend
        if(isTrendUp)
        {
            endPrice = extremum + priceShift;
        }
        else
        {
            endPrice = extremum - priceShift;
            angle = -angle; // Angolo di inversione nel downtrend
        }

        // Creare un oggetto linea di tendenza
        if(ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, TimeCurrent(), endPrice))
        {
            // Impostare le proprietà della linea di tendenza
            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());
        }
    }
}

//+------------------------------------------------------------------+
//|| Tracciare una linea del ventaglio di Gann inverso & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void DrawOppositeGannFan(double extremum, datetime extremumTime)
{
    // Definire l'angolo di Gann e il nome corrispondente.
    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"};

    // Ottenere il numero di periodi dal punto estremo alla linea K corrente
    int extremumBar = iBarShift(_Symbol, PERIOD_CURRENT, extremumTime);
    int currentBar = 0; // La linea K corrente è 0
    int barDiff = currentBar - extremumBar; // Differenza del numero di ciclo
    
    // Calcolo della differenza di altezza del prezzo
    double priceDiff;
    if(!isTrendUp)
    {
        // Inversione di tendenza (up): calcola l'altezza dal minimo estremo al prezzo massimo attuale
        double currentHigh = iHigh(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = currentHigh - extremum;
    }
    else
    {
        // Tendenza inversa (al ribasso): calcola l'altezza dal massimo estremo al prezzo minimo attuale
        double currentLow = iLow(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = extremum - currentLow;
    }
    
    // Calcolo della pendenza di base (pendenza della linea 1x1)
    double baseSlope = (barDiff > 0) ? priceDiff / barDiff : 0;
    
    // Disegnare linee di settore per ogni angolo
    for(int i = 0; i < ArraySize(angles); i++)
    {
        string label = "OppositeGannFan_" + angleNames[i];  // Etichette degli oggetti
        double angle = angles[i];                          // Angolo corrente
        
        // Calcolare il moltiplicatore della pendenza in base all'angolo
        double slopeMultiplier = MathTan(angle * M_PI / 180.0) / MathTan(45 * M_PI / 180.0);
        
        // Calcolo dell'offset del prezzo (in base alla pendenza sottostante e al moltiplicatore dell'angolo)
        double priceShift = baseSlope * barDiff * slopeMultiplier * _Point;
        double endPrice;
        
        // Calcolo del prezzo di chiusura in base alla direzione del trend inverso
        if(!isTrendUp)
        {
            endPrice = extremum + priceShift;
        }
        else
        {
            endPrice = extremum - priceShift;
            angle = -angle; // Angolo di inversione nel downtrend
        }

        // Creare un oggetto linea di tendenza
        if(ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, TimeCurrent(), endPrice))
        {
            // Impostare le proprietà della linea di tendenza
            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());
        }
    }
}





Alla fine, ho dovuto chiedere a DeepSeek di modificare il suo codice sorgente (che funziona bene e disegna le linee automaticamente): 
#property copyright "Copyright 2024, Evgeniy Shtenco"  // Informazioni sul copyright
#property link      "https://www.mql5.com/en/users/koshtenko"  // Link d'autore
#property version   "1.00"  // Numero di versione dell'indicatore
#property indicator_chart_window  // Gli indicatori sono visualizzati nella finestra del grafico

// Parametri di ingresso
input int LookBackBars = 300;      // Numero di K-linee analizzate di nuovo
input color GannFanColor = clrBlue; // I colori della linea dei fan di Vaughan

// Variabili globali
double extremumPrice;        // Prezzo estremo
datetime extremumTime;       // Punto estremo tempo
double oppositeExtremumPrice; // Prezzo estremo inverso
datetime oppositeExtremumTime; // Tempo di inversione del punto di polarità
bool isTrendUp;              // Flag di direzione del trend (vero per il trend rialzista)

//+------------------------------------------------------------------+
//| Funzioni di inizializzazione degli indicatori personalizzati & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
int OnInit()
{
    return (INIT_SUCCEEDED);  // Inizializzazione riuscita
}

//+------------------------------------------------------------------+
//| Funzioni personalizzate di deinizializzazione degli indicatori & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
    {
        // Cancellare tutti gli oggetti del settore Gann
        ObjectsDeleteAll(0, "GannFan_");
ObjectsDeleteAll(0, "OppositeGannFan_");
}

//+------------------------------------------------------------------+
//| Funzioni di calcolo degli indicatori personalizzati & nbsp; &nbsp ; | | | | | | | |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,          // Numero attuale di cicli
const int prev_calculated,      // Numero di cicli calcolati in precedenza
const datetime & time[],         // Array di tempo
                const double & open[],          // Array di prezzi di apertura
                const double & high[],           // Array dei prezzi più alti
                const double & low[],            // Array di prezzi più bassi
                const double & close[],         // Array del prezzo di chiusura
                const long & tick_volume[],      // Array di volumi
                const long & volume[],           // Array di volumi reali
                const int & spread[])            // Array di punti di diffusione
{
    if (rates_total < LookBackBars) return (0);  // Ritorno se non ci sono abbastanza dati

    // Cancella gli oggetti disegnati in precedenza
    if (prev_calculated == 0) {
        ObjectsDeleteAll(0, "GannFan_");
        ObjectsDeleteAll(0, "OppositeGannFan_");
    }

    // Trovare i punti estremi nelle ultime 300 righe K
    FindExtremums(rates_total, high, low, time);

    // Disegnare la linea del ventaglio di Venn
    DrawGannFan(extremumPrice, extremumTime);
    DrawOppositeGannFan(oppositeExtremumPrice, oppositeExtremumTime);

    return (rates_total);  // Restituisce il numero totale di colonne elaborate
}

//+------------------------------------------------------------------+
//| Trova i punti estremi all'interno di un numero specifico di linee K. |
//+------------------------------------------------------------------+
void FindExtremums(const int rates_total, const double & high[], const double & low[], const datetime & time[])
{
    int startIndex = rates_total - LookBackBars;  // Iniziare l'indicizzazione (300 K righe fa)
    int endIndex = rates_total - 1;               // Indice finale (ultima riga K)

    // Trovare alti e bassi
    int highestIndex = ArrayMaximum(high, startIndex, LookBackBars);
    int lowestIndex = ArrayMinimum(low, startIndex, LookBackBars);

    // Determinare la direzione del trend (confrontare la tempistica dei massimi e dei minimi)
    if (time[highestIndex] > time[lowestIndex]) {
        // Tendenza al ribasso se il punto più alto è successivo al punto più basso
        extremumPrice = high[highestIndex];
        extremumTime = time[highestIndex];
        oppositeExtremumPrice = low[lowestIndex];
        oppositeExtremumTime = time[lowestIndex];
        isTrendUp = false;
    }
    else {
        // altrimenti tendenza al rialzo
        extremumPrice = low[lowestIndex];
        extremumTime = time[lowestIndex];
        oppositeExtremumPrice = high[highestIndex];
        oppositeExtremumTime = time[highestIndex];
        isTrendUp = true;
    }
}

//+------------------------------------------------------------------+
//Tracciare la linea del ventaglio di Venn & nbsp; |
//+------------------------------------------------------------------+
void DrawGannFan(double extremum, datetime extremumTime)
{
    // Definire l'angolo di Gann e il nome corrispondente.
    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"};

    // Calcolare il tempo di fine della linea di settore (tempo corrente + 300 cicli)
    datetime endTime = TimeCurrent();  // Utilizzare l'ora corrente come ora di fine

    // Disegnare linee di settore per ogni angolo
    for (int i = 0; i < ArraySize(angles); i++)
    {
        string label = "GannFan_" + angleNames[i];  // Etichette degli oggetti
        double angle = angles[i];                  // Angolo corrente

        // Calcolo dello scostamento dei prezzi (in base alla differenza di orario)
        double secondsDiff = endTime - extremumTime;
        double priceShift = MathTan(angle * M_PI / 180.0) * secondsDiff / PeriodSeconds();
        double endPrice;

        // Calcolo del prezzo di chiusura in base alla direzione del trend
        if (isTrendUp) {
            endPrice = extremum + priceShift;
        }
        else {
            endPrice = extremum - priceShift;
            angle = -angle; // Angolo di inversione nel downtrend
        }

        // Creare un oggetto linea di tendenza
        if (ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, endTime, endPrice)) {
            // Impostare le proprietà della linea di tendenza
            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());
        }
    }
}

//+------------------------------------------------------------------+
//|| Tracciare una linea del ventaglio di Gann inverso & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void DrawOppositeGannFan(double extremum, datetime extremumTime)
{
    // Definire l'angolo di Gann e il nome corrispondente.
    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"};

    // Calcolare l'ora di fine della linea di settore (ora corrente)
    datetime endTime = TimeCurrent();

    // Disegnare linee di settore per ogni angolo
    for (int i = 0; i < ArraySize(angles); i++)
    {
        string label = "OppositeGannFan_" + angleNames[i];  // Etichette degli oggetti
        double angle = angles[i];                          // Angolo corrente

        // Calcolo dello scostamento dei prezzi (in base alla differenza di orario)
        double secondsDiff = endTime - extremumTime;
        double priceShift = MathTan(angle * M_PI / 180.0) * secondsDiff / PeriodSeconds();
        double endPrice;

        // Calcolo del prezzo finale in base alla direzione del trend opposto
        if (!isTrendUp) // Invertire la tendenza
        {
            endPrice = extremum + priceShift;
        }
        else {
            endPrice = extremum - priceShift;
            angle = -angle; // Angolo di inversione nel downtrend
        }

        // Creare un oggetto linea di tendenza
        if (ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, endTime, endPrice)) {
            // Impostare le proprietà della linea di tendenza
            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());
        }
    }
}

//+------------------------------------------------------------------+
//| Funzioni di gestione degli eventi del grafico &nbsp nbsp; & & nbsp; |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,                  // ID evento
const long & lparam,            // Parametri interi lunghi
                  const double & dparam,          // Parametri a doppia precisione
                  const string & sparam)         // Parametri stringa
{
    // Ridisegna gli oggetti quando il grafico cambia
    if (id == CHARTEVENT_CHART_CHANGE || id == CHARTEVENT_CLICK) {
        // Rilevare nuovamente gli estremi e tracciare la linea di Venn a ventaglio.
        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);
    }
}
File:
5h_2025-06-25.jpg  290 kb
12
Nuovo commento