Discussão do artigo "Métodos de William Gann (Parte I): Criando um indicador de ângulos de Gann" - página 2

Novo comentário
 
Vitaly Muzichenko #:

Se você fez um curso e ele não deu certo - e não dará certo, o que é lógico -, você será informado de que não está comparando corretamente as estrelas entre os planetas.

Você não está entendendo! Quem descobriu como Gunn negociou não vai ensinar ninguém. É por isso que todos os cursos de ciganos da informação são completamente falsos.

 
Bogard_11 #:

Quem quer que tenha descoberto como Gunn negociou não ensinará ninguém. É por isso que todos os cursos de ciganos da informação são falsos.

Você está dizendo a verdade, querida :-)
 
Gunn era um brilhante comerciante, astrólogo e numerólogo, um matemático que acreditava em números mágicos. Um grande adivinho que previu o início e o fim da Primeira e da Segunda Guerras Mundiais. Teve um grande número de alunos, mas, como seus seguidores afirmam, ele não dava sua estratégia a ninguém. Teve uma grande movimentação de dinheiro e, no final de sua vida, ficou com a modesta quantia de US$ 100.000. Aguardarei ansiosamente os próximos artigos sobre a personalidade genial de Gunn, muito interessantes.
 
Eva-oren #:
Gunn era um brilhante comerciante, astrólogo e numerólogo, um matemático que acreditava em números mágicos. Um grande adivinho que previu o início e o fim da Primeira e da Segunda Guerras Mundiais. Teve um grande número de alunos, mas, como seus seguidores afirmam, ele não dava sua estratégia a ninguém. Teve uma grande movimentação de dinheiro e, no final de sua vida, ficou com a modesta quantia de US$ 100.000. Aguardarei ansiosamente os próximos artigos sobre a personalidade genial de Gunn, muito interessantes.

Esqueci de mencionar que ele tinha um jato particular, o que era uma raridade naquela época. Mais US$ 100.000 na época, o que equivale a pelo menos um múltiplo de dinheiro agora, se não 10 milhões.

P.S. - Ele passou a estratégia adiante. Em seus escritos. Quem quisesse, coletado de diferentes capítulos do TC completo. Gunn espalhou tudo para que ninguém pudesse obtê-lo de graça.

 
Encontrei uma maneira de negociar no Google

 
Ivan Butko #:
Encontrei uma maneira de negociar no Google

na segunda imagem - não entendo o princípio :-(

 

Vou lhe dar uma imagem. Quem entende Gunn, entenderá imediatamente o princípio de trabalhar com curvas, onde procurar uma entrada longa e onde rolar.


 
Isenção de responsabilidade: não conheço a sintaxe de programação MQL5 para indicadores.

Mas acho que o algoritmo da linha angular não está correto (veja o indicador de linha angular em anexo que escrevi em outro software), aqui está meu diálogo com o 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;

No entanto, o DeepSeek me forneceu um código de modificação que não parecia funcionar para mim: 
//+------------------------------------------------------------------+
//| Traçando a linha do setor de Venn & nbsp; ||
//+------------------------------------------------------------------+
void DrawGannFan(double extremum, datetime extremumTime)
{
    // Defina o ângulo de Gann e o nome correspondente.
    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"};

    // Obter o número de períodos do ponto extremo até a linha K atual
    int extremumBar = iBarShift(_Symbol, PERIOD_CURRENT, extremumTime);
    int currentBar = 0; // A linha K atual é 0
    int barDiff = currentBar - extremumBar; // Diferença de número de ciclo
    
    // Calcular a diferença de altura do preço
    double priceDiff;
    if(isTrendUp)
    {
        // Tendência de alta: calcula a altura da mínima extrema até o preço máximo atual
        double currentHigh = iHigh(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = currentHigh - extremum;
    }
    else
    {
        // Tendência de baixa: calcula a altura da máxima extrema até o preço mínimo atual
        double currentLow = iLow(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = extremum - currentLow;
    }
    
    // Calcular a inclinação da base (inclinação da linha 1x1)
    double baseSlope = (barDiff > 0) ? priceDiff / barDiff : 0;
    
    // Desenhe linhas de setor para cada ângulo
    for(int i = 0; i < ArraySize(angles); i++)
    {
        string label = "GannFan_" + angleNames[i];  // Rótulos de objetos
        double angle = angles[i];                  // Ângulo atual
        
        // Calcular o multiplicador de inclinação com base no ângulo
        double slopeMultiplier = MathTan(angle * M_PI / 180.0) / MathTan(45 * M_PI / 180.0);
        
        // Calcular a compensação de preço (com base na inclinação subjacente e no multiplicador de ângulo)
        double priceShift = baseSlope * barDiff * slopeMultiplier * _Point;
        double endPrice;
        
        // Cálculo do preço de fechamento com base na direção da tendência
        if(isTrendUp)
        {
            endPrice = extremum + priceShift;
        }
        else
        {
            endPrice = extremum - priceShift;
            angle = -angle; // Ângulo de reversão na tendência de baixa
        }

        // Criar um objeto de linha de tendência
        if(ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, TimeCurrent(), endPrice))
        {
            // Definir propriedades da linha de tendência
            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());
        }
    }
}

//+------------------------------------------------------------------+
//|| Traçando uma linha de leque de Gann reverso & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void DrawOppositeGannFan(double extremum, datetime extremumTime)
{
    // Defina o ângulo de Gann e o nome correspondente.
    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"};

    // Obter o número de períodos do ponto extremo até a linha K atual
    int extremumBar = iBarShift(_Symbol, PERIOD_CURRENT, extremumTime);
    int currentBar = 0; // A linha K atual é 0
    int barDiff = currentBar - extremumBar; // Diferença de número de ciclo
    
    // Calcular a diferença de altura do preço
    double priceDiff;
    if(!isTrendUp)
    {
        // Tendência reversa (para cima): calcula a altura da mínima extrema até o preço máximo atual
        double currentHigh = iHigh(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = currentHigh - extremum;
    }
    else
    {
        // Tendência reversa (para baixo): calcula a altura da máxima extrema até o preço mínimo atual
        double currentLow = iLow(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = extremum - currentLow;
    }
    
    // Calcular a inclinação da base (inclinação da linha 1x1)
    double baseSlope = (barDiff > 0) ? priceDiff / barDiff : 0;
    
    // Desenhe linhas de setor para cada ângulo
    for(int i = 0; i < ArraySize(angles); i++)
    {
        string label = "OppositeGannFan_" + angleNames[i];  // Rótulos de objetos
        double angle = angles[i];                          // Ângulo atual
        
        // Calcular o multiplicador de inclinação com base no ângulo
        double slopeMultiplier = MathTan(angle * M_PI / 180.0) / MathTan(45 * M_PI / 180.0);
        
        // Calcular a compensação de preço (com base na inclinação subjacente e no multiplicador de ângulo)
        double priceShift = baseSlope * barDiff * slopeMultiplier * _Point;
        double endPrice;
        
        // Cálculo do preço de fechamento com base na direção da tendência inversa
        if(!isTrendUp)
        {
            endPrice = extremum + priceShift;
        }
        else
        {
            endPrice = extremum - priceShift;
            angle = -angle; // Ângulo de reversão na tendência de baixa
        }

        // Criar um objeto de linha de tendência
        if(ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, TimeCurrent(), endPrice))
        {
            // Definir propriedades da linha de tendência
            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());
        }
    }
}





No final, tive que pedir ao DeepSeek para ajustar seu código-fonte (ele funciona bem e desenha linhas automaticamente): 
#property copyright "Copyright 2024, Evgeniy Shtenco"  // Informações sobre direitos autorais
#property link      "https://www.mql5.com/en/users/koshtenko"  // Links do autor
#property version   "1.00"  // Número da versão do indicador
#property indicator_chart_window  // Os indicadores são exibidos na janela do gráfico

// Parâmetros de entrada
input int LookBackBars = 300;      // Número de linhas K analisadas de volta
input color GannFanColor = clrBlue; // Cores da linha de fãs de Vaughan

// Variáveis globais
double extremumPrice;        // Preço de ponto extremo
datetime extremumTime;       // Tempo de ponto extremo
double oppositeExtremumPrice; // Preço do ponto extremo reverso
datetime oppositeExtremumTime; // Tempo do ponto de polaridade reversa
bool isTrendUp;              // Sinalizador de direção da tendência (verdadeiro para tendência de alta)

//+------------------------------------------------------------------+
//| Funções de inicialização de indicadores personalizados & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
int OnInit()
{
    return (INIT_SUCCEEDED);  // Inicialização bem-sucedida
}

//+------------------------------------------------------------------+
//| Funções de reinicialização de indicadores personalizados & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
    {
        // Excluir todos os objetos do setor Gann
        ObjectsDeleteAll(0, "GannFan_");
ObjectsDeleteAll(0, "OppositeGannFan_");
}

//+------------------------------------------------------------------+
//| Funções de cálculo de indicador personalizado & nbsp; &nbsp ; | | | | | | | |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,          // Número atual de ciclos
const int prev_calculated,      // Número de ciclos calculados anteriormente
const datetime & time[],         // Matrizes de tempo
                const double & open[],          // Matriz de preços de abertura
                const double & high[],           // Matriz de preços mais altos
                const double & low[],            // Matriz de preços mais baixos
                const double & close[],         // Matriz de preço de fechamento
                const long & tick_volume[],      // Matriz de volume
                const long & volume[],           // Matriz de volume real
                const int & spread[])            // Matriz de spreads de pontos
{
    if (rates_total < LookBackBars) return (0);  // Retornar se não houver dados suficientes

    // Limpar os objetos desenhados anteriormente
    if (prev_calculated == 0) {
        ObjectsDeleteAll(0, "GannFan_");
        ObjectsDeleteAll(0, "OppositeGannFan_");
    }

    // Encontrar os pontos extremos nas últimas 300 K-lines
    FindExtremums(rates_total, high, low, time);

    // Desenhando a linha de Venn Fan
    DrawGannFan(extremumPrice, extremumTime);
    DrawOppositeGannFan(oppositeExtremumPrice, oppositeExtremumTime);

    return (rates_total);  // Retorna o número total de colunas processadas
}

//+------------------------------------------------------------------+
//| Encontre pontos extremos em um número especificado de linhas K. |
//+------------------------------------------------------------------+
void FindExtremums(const int rates_total, const double & high[], const double & low[], const datetime & time[])
{
    int startIndex = rates_total - LookBackBars;  // Iniciar a indexação (300 K-lines atrás)
    int endIndex = rates_total - 1;               // Índice final (última linha K)

    // Encontrando altos e baixos
    int highestIndex = ArrayMaximum(high, startIndex, LookBackBars);
    int lowestIndex = ArrayMinimum(low, startIndex, LookBackBars);

    // Determinar a direção da tendência (comparar o momento dos altos e baixos)
    if (time[highestIndex] > time[lowestIndex]) {
        // Tendência de baixa se o ponto mais alto estiver após o ponto mais baixo
        extremumPrice = high[highestIndex];
        extremumTime = time[highestIndex];
        oppositeExtremumPrice = low[lowestIndex];
        oppositeExtremumTime = time[lowestIndex];
        isTrendUp = false;
    }
    else {
        // caso contrário, tendência de alta
        extremumPrice = low[lowestIndex];
        extremumTime = time[lowestIndex];
        oppositeExtremumPrice = high[highestIndex];
        oppositeExtremumTime = time[highestIndex];
        isTrendUp = true;
    }
}

//+------------------------------------------------------------------+
//| Traçando a linha do setor de Venn & nbsp; ||
//+------------------------------------------------------------------+
void DrawGannFan(double extremum, datetime extremumTime)
{
    // Defina o ângulo de Gann e o nome correspondente.
    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"};

    // Calcular o tempo final da linha de setor (tempo atual + 300 ciclos)
    datetime endTime = TimeCurrent();  // Usar a hora atual como hora final

    // Desenhe linhas de setor para cada ângulo
    for (int i = 0; i < ArraySize(angles); i++)
    {
        string label = "GannFan_" + angleNames[i];  // Rótulos de objetos
        double angle = angles[i];                  // Ângulo atual

        // Calcular a compensação de preço (com base na diferença de horário)
        double secondsDiff = endTime - extremumTime;
        double priceShift = MathTan(angle * M_PI / 180.0) * secondsDiff / PeriodSeconds();
        double endPrice;

        // Cálculo do preço de fechamento com base na direção da tendência
        if (isTrendUp) {
            endPrice = extremum + priceShift;
        }
        else {
            endPrice = extremum - priceShift;
            angle = -angle; // Ângulo de reversão na tendência de baixa
        }

        // Criar um objeto de linha de tendência
        if (ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, endTime, endPrice)) {
            // Definir propriedades da linha de tendência
            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());
        }
    }
}

//+------------------------------------------------------------------+
//|| Traçando uma linha de leque de Gann reverso & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void DrawOppositeGannFan(double extremum, datetime extremumTime)
{
    // Defina o ângulo de Gann e o nome correspondente.
    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"};

    // Calcular o tempo final da linha de setor (hora atual)
    datetime endTime = TimeCurrent();

    // Desenhe linhas de setor para cada ângulo
    for (int i = 0; i < ArraySize(angles); i++)
    {
        string label = "OppositeGannFan_" + angleNames[i];  // Rótulos de objetos
        double angle = angles[i];                          // Ângulo atual

        // Calcular a compensação de preço (com base na diferença de horário)
        double secondsDiff = endTime - extremumTime;
        double priceShift = MathTan(angle * M_PI / 180.0) * secondsDiff / PeriodSeconds();
        double endPrice;

        // Cálculo do preço final com base na direção da tendência oposta
        if (!isTrendUp) // Tendência inversa
        {
            endPrice = extremum + priceShift;
        }
        else {
            endPrice = extremum - priceShift;
            angle = -angle; // Ângulo de reversão na tendência de baixa
        }

        // Criar um objeto de linha de tendência
        if (ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, endTime, endPrice)) {
            // Definir propriedades da linha de tendência
            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());
        }
    }
}

//+------------------------------------------------------------------+
//| Funções do manipulador de eventos do gráfico &nbsp nbsp; & & & nbsp; &|
//+------------------------------------------------------------------+
void OnChartEvent(const int id,                  // ID do evento
const long & lparam,            // Parâmetros inteiros longos
                  const double & dparam,          // Parâmetros de precisão dupla
                  const string & sparam)         // Parâmetros de cadeia de caracteres
{
    // Redesenhar objetos quando o gráfico for alterado
    if (id == CHARTEVENT_CHART_CHANGE || id == CHARTEVENT_CLICK) {
        // Encontre novamente os extremos e trace a linha do leque 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);
    }
}
Arquivos anexados:
5h_2025-06-25.jpg  290 kb
12
Novo comentário