Discusión sobre el artículo "Métodos de William Gann (Parte I): Creación del indicador de ángulos de Gann" - página 2

Nuevo comentario
 
Vitaly Muzichenko #:

Si ha hecho un curso y no le ha salido bien -y no le saldrá bien, lo cual es lógico-, le dirán que no está comparando correctamente las estrellas entre los planetas.

Quien ha descubierto como operaba Gunn, no va a enseñar a nadie. Por eso todos los cursos de los gitanos de la información son una completa farsa.

 
Bogard_11 #:

¡No lo entiendes! Quien descubrió cómo operaba Gunn no enseña a nadie. Es por eso que todos los cursos de los gitanos de la información no son más que falsos.

Estás diciendo la verdad, querido :-)
 
Gunn era un brillante comerciante, astrólogo y numerólogo, un matemático que creía en los números mágicos. Un gran adivino que predijo el principio y el final de la Primera y la Segunda Guerra Mundial. Tuvo un enorme número de alumnos, pero como afirman sus seguidores, no dio su estrategia a nadie. Tuvo un enorme movimiento de dinero, y al final de su vida se hizo con la modesta suma de 100.000 dólares. Esperaré con impaciencia los próximos artículos sobre la genial personalidad de Gunn, muy interesantes.
 
Eva-oren #:
Gunn era un brillante comerciante, astrólogo y numerólogo, un matemático que creía en los números mágicos. Un gran adivino que predijo el principio y el final de la Primera y la Segunda Guerra Mundial. Tuvo un enorme número de alumnos, pero como afirman sus seguidores, no dio su estrategia a nadie. Tuvo un enorme movimiento de dinero, y al final de su vida se hizo con la modesta suma de 100.000 dólares. Esperaré con impaciencia los próximos artículos sobre la genial personalidad de Gunn, muy interesantes.

Olvidé mencionar que tenía un jet privado, lo cual era una rareza en aquellos tiempos. Más 100.000 dólares en aquel entonces, eso es por lo menos una mulit de verde ahora, si no 10 mulit.

P.D. - pasó de la estrategia. En sus escritos. Quien quiso, recopilados de diferentes capítulos del TC completo. Gunn lo dispersó todo para que nadie pudiera conseguirlo gratis.

 
Encontrado una manera de negociar en google

 
Ivan Butko #:
Encontrado una manera de negociar en Google

en la segunda imagen - No entiendo el principio :-(

 

Te daré una imagen. Quién entiende Gunn, entenderá inmediatamente el principio de trabajar con esquinas, dónde buscar una entrada larga y dónde rodar.


 
Descargo de responsabilidad: No sé MQL5 sintaxis de programación para los indicadores.

Pero creo que el algoritmo de la línea de ángulo no es correcto (ver adjunto indicador de línea de ángulo que escribí en otro software), aquí está mi diálogo 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;

Sin embargo, DeepSeek me dio un código de modificación que no parecía funcionar para mí: 
//+------------------------------------------------------------------+
//| Trazar la línea del sector de Venn & nbsp; ||
//+------------------------------------------------------------------+
void DrawGannFan(double extremum, datetime extremumTime)
{
    // Define el ángulo de Gann y el nombre correspondiente.
    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"};

    // Obtiene el número de periodos desde el punto extremo hasta la línea K actual
    int extremumBar = iBarShift(_Symbol, PERIOD_CURRENT, extremumTime);
    int currentBar = 0; // La línea K actual es 0
    int barDiff = currentBar - extremumBar; // Diferencia de número de ciclo
    
    // Calcular la diferencia de altura de precios
    double priceDiff;
    if(isTrendUp)
    {
        // Tendencia alcista: calcula la altura desde el mínimo extremo hasta el precio máximo actual
        double currentHigh = iHigh(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = currentHigh - extremum;
    }
    else
    {
        // Tendencia bajista: calcula la altura desde el máximo extremo hasta el precio mínimo actual
        double currentLow = iLow(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = extremum - currentLow;
    }
    
    // Calcular la pendiente de la base (pendiente de la línea 1x1)
    double baseSlope = (barDiff > 0) ? priceDiff / barDiff : 0;
    
    // Dibuja líneas de sector para cada ángulo
    for(int i = 0; i < ArraySize(angles); i++)
    {
        string label = "GannFan_" + angleNames[i];  // Etiquetas de objetos
        double angle = angles[i];                  // Ángulo actual
        
        // Calcular el multiplicador de la pendiente en función del ángulo
        double slopeMultiplier = MathTan(angle * M_PI / 180.0) / MathTan(45 * M_PI / 180.0);
        
        // Calcular el desplazamiento del precio (en función de la pendiente subyacente y del multiplicador del ángulo)
        double priceShift = baseSlope * barDiff * slopeMultiplier * _Point;
        double endPrice;
        
        // Cálculo del precio de cierre en función de la dirección de la tendencia
        if(isTrendUp)
        {
            endPrice = extremum + priceShift;
        }
        else
        {
            endPrice = extremum - priceShift;
            angle = -angle; // Ángulo de inversión en tendencia bajista
        }

        // Crear un objeto línea de tendencia
        if(ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, TimeCurrent(), endPrice))
        {
            // Establecer las propiedades de la línea de tendencia
            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());
        }
    }
}

//+------------------------------------------------------------------+
//|| Trazado de una línea de abanico de Gann inverso & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void DrawOppositeGannFan(double extremum, datetime extremumTime)
{
    // Define el ángulo de Gann y el nombre correspondiente.
    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"};

    // Obtiene el número de periodos desde el punto extremo hasta la línea K actual
    int extremumBar = iBarShift(_Symbol, PERIOD_CURRENT, extremumTime);
    int currentBar = 0; // La línea K actual es 0
    int barDiff = currentBar - extremumBar; // Diferencia de número de ciclo
    
    // Calcular la diferencia de altura de precios
    double priceDiff;
    if(!isTrendUp)
    {
        // Tendencia inversa (alcista): calcula la altura desde el mínimo extremo hasta el precio máximo actual.
        double currentHigh = iHigh(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = currentHigh - extremum;
    }
    else
    {
        // Tendencia inversa (bajista): calcula la altura desde el máximo extremo hasta el precio mínimo actual.
        double currentLow = iLow(_Symbol, PERIOD_CURRENT, 0);
        priceDiff = extremum - currentLow;
    }
    
    // Calcular la pendiente de la base (pendiente de la línea 1x1)
    double baseSlope = (barDiff > 0) ? priceDiff / barDiff : 0;
    
    // Dibuja líneas de sector para cada ángulo
    for(int i = 0; i < ArraySize(angles); i++)
    {
        string label = "OppositeGannFan_" + angleNames[i];  // Etiquetas de objetos
        double angle = angles[i];                          // Ángulo actual
        
        // Calcular el multiplicador de la pendiente en función del ángulo
        double slopeMultiplier = MathTan(angle * M_PI / 180.0) / MathTan(45 * M_PI / 180.0);
        
        // Calcular el desplazamiento del precio (en función de la pendiente subyacente y del multiplicador del ángulo)
        double priceShift = baseSlope * barDiff * slopeMultiplier * _Point;
        double endPrice;
        
        // Cálculo del precio de cierre basado en la dirección de la tendencia inversa
        if(!isTrendUp)
        {
            endPrice = extremum + priceShift;
        }
        else
        {
            endPrice = extremum - priceShift;
            angle = -angle; // Ángulo de inversión en tendencia bajista
        }

        // Crear un objeto línea de tendencia
        if(ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, TimeCurrent(), endPrice))
        {
            // Establecer las propiedades de la línea de tendencia
            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());
        }
    }
}





Al final, tuve que pedirle a DeepSeek que modificara su código fuente (funciona bien y dibuja las líneas automáticamente): 
#property copyright "Copyright 2024, Evgeniy Shtenco"  // Información sobre derechos de autor
#property link      "https://www.mql5.com/en/users/koshtenko"  // Enlaces de autores
#property version   "1.00"  // Número de versión del indicador
#property indicator_chart_window  // Los indicadores se muestran en la ventana del gráfico

// Parámetros de entrada
input int LookBackBars = 300;      // Número de líneas K analizadas atrás
input color GannFanColor = clrBlue; // Los colores de la línea de fans de Vaughan

// Variables globales
double extremumPrice;        // Precio del punto extremo
datetime extremumTime;       // Momento extremo
double oppositeExtremumPrice; // Precio del punto extremo inverso
datetime oppositeExtremumTime; // Inversión del punto de polaridad
bool isTrendUp;              // Indicador de dirección de la tendencia (verdadero para tendencia alcista)

//+------------------------------------------------------------------+
//| Funciones de Inicialización de Indicadores Personalizados & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
int OnInit()
{
    return (INIT_SUCCEEDED);  // Inicialización correcta
}

//+------------------------------------------------------------------+
//| Funciones personalizadas de reinicialización de indicadores & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
    {
        // Borrar todos los objetos del sector Gann
        ObjectsDeleteAll(0, "GannFan_");
ObjectsDeleteAll(0, "OppositeGannFan_");
}

//+------------------------------------------------------------------+
//| Funciones de cálculo de indicadores personalizados & nbsp; &nbsp ; | | | | | | | |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,          // Número actual de ciclos
const int prev_calculated,      // Número de ciclos calculados previamente
const datetime & time[],         // Matrices temporales
                const double & open[],          // Matriz de precios de apertura
                const double & high[],           // Matriz de precios más altos
                const double & low[],            // Matriz de precios más bajos
                const double & close[],         // Matriz de precios de cierre
                const long & tick_volume[],      // Matriz de volumen
                const long & volume[],           // Matriz de volumen real
                const int & spread[])            // Matriz de diferenciales de puntos
{
    if (rates_total < LookBackBars) return (0);  // Devuelve si no hay suficientes datos

    // Borrar los objetos dibujados anteriormente
    if (prev_calculated == 0) {
        ObjectsDeleteAll(0, "GannFan_");
        ObjectsDeleteAll(0, "OppositeGannFan_");
    }

    // Encontrar los puntos extremos en las últimas 300 K-líneas
    FindExtremums(rates_total, high, low, time);

    // Trazar la línea de abanico de Venn
    DrawGannFan(extremumPrice, extremumTime);
    DrawOppositeGannFan(oppositeExtremumPrice, oppositeExtremumTime);

    return (rates_total);  // Devuelve el número total de columnas procesadas
}

//+------------------------------------------------------------------+
//| Encontrar puntos extremos dentro de un número especificado de líneas K. |
//+------------------------------------------------------------------+
void FindExtremums(const int rates_total, const double & high[], const double & low[], const datetime & time[])
{
    int startIndex = rates_total - LookBackBars;  // Comienza la indexación (hace 300 K-líneas)
    int endIndex = rates_total - 1;               // Índice final (última línea K)

    // Encontrar altos y bajos
    int highestIndex = ArrayMaximum(high, startIndex, LookBackBars);
    int lowestIndex = ArrayMinimum(low, startIndex, LookBackBars);

    // Determinar la dirección de la tendencia (comparar el momento de máximos y mínimos)
    if (time[highestIndex] > time[lowestIndex]) {
        // Tendencia bajista si el punto más alto está después del punto más bajo
        extremumPrice = high[highestIndex];
        extremumTime = time[highestIndex];
        oppositeExtremumPrice = low[lowestIndex];
        oppositeExtremumTime = time[lowestIndex];
        isTrendUp = false;
    }
    else {
        // en caso contrario, tendencia alcista
        extremumPrice = low[lowestIndex];
        extremumTime = time[lowestIndex];
        oppositeExtremumPrice = high[highestIndex];
        oppositeExtremumTime = time[highestIndex];
        isTrendUp = true;
    }
}

//+------------------------------------------------------------------+
//| Trazar la línea del sector de Venn & nbsp; ||
//+------------------------------------------------------------------+
void DrawGannFan(double extremum, datetime extremumTime)
{
    // Define el ángulo de Gann y el nombre correspondiente.
    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 el tiempo final de la línea de sector (tiempo actual + 300 ciclos)
    datetime endTime = TimeCurrent();  // Utilizar la hora actual como hora final

    // Dibuja líneas de sector para cada ángulo
    for (int i = 0; i < ArraySize(angles); i++)
    {
        string label = "GannFan_" + angleNames[i];  // Etiquetas de objetos
        double angle = angles[i];                  // Ángulo actual

        // Calcular la diferencia de precio (en función de la diferencia horaria)
        double secondsDiff = endTime - extremumTime;
        double priceShift = MathTan(angle * M_PI / 180.0) * secondsDiff / PeriodSeconds();
        double endPrice;

        // Cálculo del precio de cierre en función de la dirección de la tendencia
        if (isTrendUp) {
            endPrice = extremum + priceShift;
        }
        else {
            endPrice = extremum - priceShift;
            angle = -angle; // Ángulo de inversión en tendencia bajista
        }

        // Crear un objeto línea de tendencia
        if (ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, endTime, endPrice)) {
            // Establecer las propiedades de la línea de tendencia
            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());
        }
    }
}

//+------------------------------------------------------------------+
//|| Trazado de una línea de abanico de Gann inverso & nbsp; &nbsp ; ||
//+------------------------------------------------------------------+
void DrawOppositeGannFan(double extremum, datetime extremumTime)
{
    // Define el ángulo de Gann y el nombre correspondiente.
    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 la hora final de la línea de sector (hora actual)
    datetime endTime = TimeCurrent();

    // Dibuja líneas de sector para cada ángulo
    for (int i = 0; i < ArraySize(angles); i++)
    {
        string label = "OppositeGannFan_" + angleNames[i];  // Etiquetas de objetos
        double angle = angles[i];                          // Ángulo actual

        // Calcular la diferencia de precio (en función de la diferencia horaria)
        double secondsDiff = endTime - extremumTime;
        double priceShift = MathTan(angle * M_PI / 180.0) * secondsDiff / PeriodSeconds();
        double endPrice;

        // Cálculo del precio final basado en la dirección de la tendencia opuesta
        if (!isTrendUp) // Invertir la tendencia
        {
            endPrice = extremum + priceShift;
        }
        else {
            endPrice = extremum - priceShift;
            angle = -angle; // Ángulo de inversión en tendencia bajista
        }

        // Crear un objeto línea de tendencia
        if (ObjectCreate(0, label, OBJ_TREND, 0, extremumTime, extremum, endTime, endPrice)) {
            // Establecer las propiedades de la línea de tendencia
            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());
        }
    }
}

//+------------------------------------------------------------------+
//| Funciones del Manejador de Eventos de Gráficos &nbsp nbsp; & & nbsp; |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,                  // ID del evento
const long & lparam,            // Parámetros enteros largos
                  const double & dparam,          // Parámetros de doble precisión
                  const string & sparam)         // Parámetros de cadena
{
    // Redibujar objetos cuando cambia el gráfico
    if (id == CHARTEVENT_CHART_CHANGE || id == CHARTEVENT_CLICK) {
        // Vuelve a encontrar los extremos y traza la línea de abanico 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);
    }
}
Archivos adjuntos:
5h_2025-06-25.jpg  290 kb
12
Nuevo comentario