Análisis de estrategias de operaciones de alta frecuencia - Penny Jump

El comercio de alta frecuencia es un campo lleno de desafíos y competencia, que depende de la ejecución rápida de transacciones y de una sensibilidad a la estructura microscópica del mercado. Una de las estrategias más populares es el Penny Jump, que se centra en aprovechar el "elefante" en el mercado para obtener ganancias pequeñas pero frecuentes. En este artículo, explicaremos en detalle cómo funciona la estrategia Penny Jump, al tiempo que profundizaremos en los detalles del código de la estrategia para que los principiantes entiendan cómo funciona.

Comprender las estrategias de Penny Jump

En el mercado de valores, el "elefante" se refiere generalmente a los inversores institucionales que desean comprar o vender una gran cantidad de acciones, pero no están dispuestos a operar a precios de mercado. En cambio, eligen colgar una gran cantidad de listados de precio, o listados, en el mercado para mostrar su intención.

Por ejemplo, supongamos que la profundidad de mercado de una acción era así: 200 $1.01 x $1.03 200; luego, un elefante entra y cuelga una factura de 3.000 acciones por $1.01; entonces, la profundidad de mercado se convierte en 3,200; $1.01 x $1.03 200; esto es como introducir un elefante que se convierte en el foco de atención de los otros participantes en el mercado.

• El mercado de la competencia Para los comerciantes de alta frecuencia, sus ganancias provienen principalmente del análisis de la estructura microscópica del mercado para especular sobre las intenciones de otros comerciantes. Una vez que aparece un elefante, los comerciantes de alta frecuencia establecerán rápidamente posiciones para obtener pequeñas fluctuaciones de precios. Su objetivo es operar con frecuencia en un corto período de tiempo, acumulando ganancias pequeñas pero acumuladas.

• El problema de los elefantes Aunque los elefantes pueden querer operar en grandes cantidades en el mercado, su comportamiento también expone sus intenciones comerciales, lo que los convierte en objetivos de los operadores de alta frecuencia. Los operadores de alta frecuencia intentan establecer posiciones con anticipación y luego obtener ganancias en las fluctuaciones de precios. La presencia de los elefantes en el mercado puede provocar una reacción competitiva del mercado, lo que influye en su estrategia de negociación.

• El engaño en el mercado En realidad, los grandes inversores institucionales no suelen poner en el mercado órdenes de compra o venta en grandes cantidades, ya que este comportamiento puede llevar a otros participantes en el mercado a tomar medidas de contraataque o incluso a manipular el mercado. Por lo tanto, pueden adoptar estrategias para fabricar una ilusión, atraer a los operadores de alta frecuencia, y luego vender o comprar rápidamente para obtener ganancias de la fluctuación de los precios.

La idea central de la estrategia Penny Jump

La idea central de la estrategia del Penny Jump es que una vez que un elefante aparece en el mercado y apoya un determinado precio (por ejemplo, $1.01), los operadores de alta frecuencia aumentarán rápidamente sus ofertas por un centavo, por ejemplo, a $1.02. Esto se debe a que los operadores de alta frecuencia entienden que la aparición de un elefante significa que el precio tiene un fuerte soporte de compra, por lo que tratan de seguirlo para esperar que el precio suba. Cuando el precio realmente sube a $1.03 x $1.05, los operadores de alta frecuencia pueden vender rápidamente para obtener una ganancia de $0.01.

Además, los operadores de alta frecuencia pueden obtener ganancias después de comprar, incluso si el precio no sube. Ya que saben que el elefante sostiene el precio inferior, pueden vender rápidamente las acciones al elefante y obtener una pequeña ganancia por diferencia.

Descifrar el código de la política Penny Jump

El código fuente de la estrategia:https://www.fmz.com/strategy/358

El código de la política que se proporciona arriba es un ejemplo de cómo se puede implementar la política Penny Jump. A continuación se explica en detalle el código para que los principiantes entiendan cómo funciona:

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

// Variables
var InitAccount = null;

function CancelAll() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        for (var i = 0; i < orders.length; i++) {
            exchange.CancelOrder(orders[i].Id);
        }
        Sleep(Interval);
    }
}

function updateStatus(msg) {
    LogStatus("调戏次数:", Counter.i, "成功:", Counter.w, "失败:", Counter.f, "\n"+msg+"#0000ff\n"+new Date());
}

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("买单得手: " + opAmount +", 开始出手...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

Voy a analizar el código de la estrategia que usted me ha proporcionado para ayudarle a entender cómo funciona en mayor detalle.

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

Este código inicializa un objeto llamado Counter, que se utiliza para rastrear la estadística de transacciones de la política. En concreto, incluye tres propiedades:

• i: Indica el número total de transacciones.
• w: Indica el número de transacciones exitosas.
• f: Indica el número de transacciones fallidas.

Estas propiedades se registran y actualizan durante la ejecución de la política.

var InitAccount = null;

Esta línea de código inicializa una variable llamada InitAccount, que almacenará la información de la cuenta cuando la política comience a ejecutarse.

function CancelAll() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        for (var i = 0; i < orders.length; i++) {
            exchange.CancelOrder(orders[i].Id);
        }
        Sleep(Interval);
    }
}

Se trata de unCancelAll()La función de eliminación de pedidos no completados en el mercado.

• while (true): es un ciclo infinito que continuará ejecutándose hasta que no haya pedidos sin completar.
• var orders = _C(exchange.GetOrders)：这一行代码使用exchange.GetOrders函数获取当前账户所有挂出的订单，并将它们存储在orders变量中。
• if (orders.length == 0): esta línea de código comprueba si hay pedidos incompletos. Si la longitud de la matriz de pedidos es 0, significa que no hay pedidos incompletos, el ciclo se interrumpe.
• for (var i = 0; i < orders.length; i++): es un ciclo for, que recorre todos los pedidos pendientes.
• exchange.CancelOrder(orders[i].Id): Esta línea de código utiliza la función exchange.CancelOrder (), para cancelar cada pedido con el ID de la orden.
• Sleep(Interval): Esta línea de código introduce un ciclo de espera, que se espera durante un tiempo (en milisegundos) para asegurar que la operación de cancelación de la orden no sea demasiado frecuente.

El objetivo de esta función es asegurarse de que no haya órdenes pendientes antes de ejecutar la política principal, para evitar interferir con la ejecución de la política principal.

function updateStatus(msg) {
    LogStatus("调戏次数:", Counter.i, "成功:", Counter.w, "失败:", Counter.f, "\n" + msg + "#0000ff\n" + new Date());
}

Se trata de unupdateStatus(msg)Una función de la que se utiliza para actualizar la información sobre el estado de las transacciones y registrarlas. Acepta un parámetro msg que normalmente contiene información sobre el estado actual del mercado. Las operaciones específicas de la función incluyen:

UsoLogStatus()La función registra la información que se muestra en la barra de estado cuando se ejecuta la política. Muestra texto sobre el número de transacciones, el número de éxitos y el número de fracasos. AñadidomsgParámetros que contienen información sobre el estado actual del mercado. Añadido el botón de tiempo actualnew Date()La información de la hora se muestra en la página web. El propósito de esta función es registrar y actualizar la información sobre el estado de las transacciones para realizar monitoreo y análisis durante la ejecución de la estrategia.

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("买单得手: " + opAmount +", 开始出手...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

Esta es la principal función ejecutiva de la estrategia.main()En el caso de los blogs, los blogs y las redes sociales, la mayoría de los sitios web de Facebook están diseñados para ayudar a los usuarios a crear sus propias páginas web.

• if (DisableLog): esta línea de código comprueba si la variable DisableLog es verdadera y, si es así, desactiva los registros de registro. Esto es para asegurar que la política no registre registros innecesarios.

• CancelAll(): Llama a la función CancelAll (() explicada anteriormente para asegurarse de que no hay pedidos pendientes.

• InitAccount = _C(exchange.GetAccount): Esta línea de código obtiene información de la cuenta actual y la almacena en la variable InitAccount. Esto se usará para registrar el estado de la cuenta cuando la política se inicie.

• var i = 0;yvar locks = 0;: inicializa las dos variables i y locks, que se utilizarán en la lógica de la estrategia posterior.

• while (true): es un ciclo infinito, utilizado principalmente para la ejecución continua de estrategias.

A continuación, vamos a explicarlas línea por línea.while (true)La lógica estratégica principal dentro del ciclo.

while (true) {
    Sleep(Interval);
    var depth = _C(exchange.GetDepth);
    if (depth.Asks.length === 0 || depth.Bids.length === 0) {
        continue;
    }
    updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);

• Sleep(Interval): esta línea de código deja la política en reposo durante un tiempo para controlar la frecuencia de ejecución de la política. El parámetro Interval define el intervalo de tiempo en reposo (en milisegundos).

• var depth = _C(exchange.GetDepth)Obtener información de profundidad del mercado actual, incluyendo precios y cantidades de pedidos y pedidos. Esta información se almacena en variables de profundidad.

• if (depth.Asks.length === 0 || depth.Bids.length === 0): esta línea de código revisa la información de profundidad del mercado para asegurarse de que existen las ofertas de venta y las ofertas de compra. Si una de ellas no existe, significa que el mercado puede no tener suficiente información de transacción, entonces la estrategia continúa esperando.

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks)Esta línea de código llama a la función update Status, información sobre el estado de la política de actualización. Registra el estado actual del mercado, incluidos los precios de compra, venta y bloqueo anterior.

    var askPrice = 0;
    for (i = 0; i < depth.Asks.length; i++) {
        if (depth.Asks[i].Amount >= Lot) {
            askPrice = depth.Asks[i].Price;
            break;
        }
    }
    if (askPrice === 0) {
        continue;
    }
    var elephant = null;

• var askPrice = 0;: inicializa la variable askPrice, que se usará para almacenar el precio de una venta que cumple con las condiciones.

• for (i = 0; i < depth.Asks.length; i++): es un for loop que se utiliza para recorrer la información de precios y cantidades de los pedidos de venta en el mercado.

• if (depth.Asks[i].Amount >= Lot): En el ciclo, comprueba si el número de cada orden de venta es mayor o igual al Lot (número de manos) especificado. Si es así, almacena el precio de la orden de venta en el AskPrice y termina el ciclo.

• if (askPrice === 0): Si no se encuentra una oferta que cumpla con las condiciones (askPrice sigue siendo 0), la política continúa esperando y se salta la siguiente operación.

• var elephant = null;: inicializa la variable elephant, que se utilizará para almacenar la información de pago de la identificación de la mandíbula de elefante.

    for (i = 1; i < depth.Bids.length; i++) {
        if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
            break;
        }
        if (depth.Bids[i].Amount >= ElephantAmount) {
            elephant = depth.Bids[i];
            break;
        }
    }

    if (!elephant) {
        locks = 0;
        continue;
    }
    locks++;
    if (locks < LockCount) {
        continue;
    }
    locks = 0;

Para seguir recorriendo el mercado con información sobre precios y cantidades de ofertas, salta la primera oferta (Bids[0]) ].

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace): comprobar si la brecha entre el precio de compra actual y el precio de compra es mayor que el de ElephantSpace. Si es así, indica que está lo suficientemente lejos de la casa de elefantes para que la estrategia deje de buscar.

• if (depth.Bids[i].Amount >= ElephantAmount): comprueba si el número de pagos actuales es mayor o igual a ElephantAmount, y si es así, almacena la información del pago en la variable elephant.

• if (!elephant): Si no se encuentra el cuello de elefante, se restablecerán los bloqueos numéricos de bloqueo a 0 y se continuará esperando.

locks++: si se encuentra una alcachofa, se incrementará el número de bloqueos. Esto es para asegurar que la política se ejecute después de confirmar la existencia de la alcachofa varias veces en un período de tiempo.

• if (locks < LockCount): comprueba si se cumple el número de bloqueos requerido (LockCount); si no se cumple, continúa esperando.

    updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
    exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
    var ts = new Date().getTime();
    while (true) {
        Sleep(CheckInterval);
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        if ((new Date().getTime() - ts) > WaitInterval) {
            for (var i = 0; i < orders.length; i++) {
                exchange.CancelOrder(orders[i].Id);
            }
        }
    }

• updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant)): Llama a la función Update Status, que registra el estado actual de la política, incluido el rango y la información relacionada con el cascarón de elefante encontrado. Esto se mostrará en la barra de estado de la política.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): usar la función exchange.Buy para comprar un elefante encontrado. El precio de compra es elephant.Price + PennyTick, la cantidad de compras es Lot, y la operación de compra se describe como "Bids[" + i + ] elephant".

• var ts = new Date().getTime(): obtiene el tiempo de la hora actual para calcular el intervalo de tiempo posterior.

• while (true)En la actualidad, la mayoría de las personas que buscan comprar un elefante se encuentran en el mismo círculo.

• Sleep(CheckInterval)La estrategia está inactivada durante un tiempo para controlar la frecuencia con la que se revisa el estado de los pedidos.

• var orders = _C(exchange.GetOrders)En la página web de la empresa, se puede encontrar información de todos los pedidos de la cuenta actual.

• if (orders.length == 0): comprueba si hay pedidos pendientes, si no, salta del ciclo.

• (new Date().getTime() - ts) > WaitInterval: Calcula el intervalo de tiempo entre el tiempo actual y el momento en que se compró el pollo de elefante, si se excede el Intervalo de espera, se indica que el tiempo de espera es superior.

• for (var i = 0; i < orders.length; i++)En la página de Facebook de la empresa, se puede leer: "Revisar todos los pedidos pendientes".

• exchange.CancelOrder(orders[i].Id)：使用exchange.CancelOrder函数取消每个未完成的订单。

    var account = _C(exchange.GetAccount);
    var opAmount = _N(account.Stocks - InitAccount.Stocks);
    if (opAmount < 0.001) {
        Counter.f++;
        Counter.i++;
        continue;
    }
    updateStatus("买单得手: " + opAmount + ", 开始出手...");
    exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
    var success = true;
    while (true) {
        var depth = _C(exchange.GetDepth);
        if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))) {
            success = false;
            updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
            CancelAll();
            account = _C(exchange.GetAccount);
            var opAmount = _N(account.Stocks - InitAccount.Stocks);
            if (opAmount < 0.001) {
                break;
            }
            exchange.Sell(depth.Bids[0].Price, opAmount);
        }
        var orders = _C(exchange.GetOrders);
        if (orders.length === 0) {
            break;
        }
        Sleep(CheckInterval);
    }
    if (success) {
        Counter.w++;
    } else {
        Counter.f++;
    }
    Counter.i++;
    var account = _C(exchange.GetAccount);
    LogProfit(account.Balance - InitAccount.Balance, account);
}

• var account = _C(exchange.GetAccount)En la página web de Facebook, el usuario puede acceder a la siguiente información:

• var opAmount = _N(account.Stocks - InitAccount.Stocks)Si el cambio es menor a 0.001, indica que la compra ha fracasado, se aumentará el número de fracasos y se continuará el siguiente ciclo.

• updateStatus("买单得手: " + opAmount + ", 开始出手...")Los datos de las compras de plumas de elefante, incluidas las cantidades compradas.

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): con la función exchange.Sell, vende el elefante con el que has comprado con éxito para obtener una ganancia. El precio de venta es elephant.Price + (PennyTick * ProfitTick).

Entrar en un nuevo ciclo infinito para la ejecución de pedidos de venta en espera.

• var depth = _C(exchange.GetDepth)En la actualidad, la mayoría de los usuarios de Twitter están conectados a Facebook.

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick)))Si el precio del mercado ha caído a un precio de stop loss, ejecuta una operación de stop loss.

• CancelAll()Llama a la función: CancelAll para cancelar todos los pedidos pendientes para evitar el riesgo de almacenamiento.

• if (opAmount < 0.001): vuelve a comprobar la cantidad de compras, si es menor a 0.001, indica que la compra ha fracasado y salta del ciclo.

• exchange.Sell(depth.Bids[0].Price, opAmount)Los activos restantes se venden al precio más bajo del mercado actual.

Finalmente, se actualizan los números de éxito y de fracaso según el éxito de la transacción y se registra el beneficio de la transacción.

Esta es la explicación de la estrategia en línea. La idea central de esta estrategia es buscar elefantes en el mercado (pagando mucho) y comprarlos y venderlos para obtener una pequeña ganancia. Incluye varios parámetros importantes, como el número de compras (Lot), el intervalo de repetición de errores (Interval), el nivel de elefantes (ElephantAmount) y la distancia de elefantes (ElephantSpace), para ajustar el comportamiento de la estrategia.

En general, esta estrategia es una estrategia de negociación de alta frecuencia que se basa en la información de profundidad del mercado, la identificación de grandes cantidades de pagos y la realización de operaciones de venta y venta en un corto período de tiempo. Requiere monitorear continuamente el mercado y realizar operaciones de venta y venta para obtener rápidamente pequeñas ganancias. Sin embargo, también es una estrategia de alto riesgo, ya que requiere una rápida reacción a las fluctuaciones del mercado, al tiempo que requiere considerar la gestión del riesgo y los mecanismos de stop loss para evitar pérdidas significativas.

Tenga en cuenta que esta estrategia se basa en mercados y plataformas de negociación específicos, y que puede ser necesario realizar los ajustes y optimizaciones apropiados para diferentes mercados y intercambios. En aplicaciones prácticas, los inversores deben probar y evaluar cuidadosamente el rendimiento de la estrategia para asegurarse de que cumple con sus objetivos de inversión y su capacidad de asumir riesgos.

Mientras continúas ejecutando la política, ella continuará ejecutando los siguientes pasos en un ciclo:

Primero, la estrategia examina información profunda del mercado para conocer las ofertas y compras actuales.

2, La siguiente estrategia intentará encontrar las ofertas que cumplan con los requisitos, con la condición de que el número de ofertas sea mayor o igual a Lot (número de manos). Si se encuentra una oferta que cumple los requisitos, el precio de la oferta se registrará como AskPrice.

3, Luego, la estrategia continúa buscando el cascarón del elefante (muchas compras) ; se recorre el mercado y se salta el primer cascarón (generalmente el de mayor precio); si se encuentra el cascarón del elefante que cumple con los requisitos, se registra la información del cascarón del elefante y se aumenta el número de bloqueos (bloques).

4. Si se encuentra una cantidad suficiente de cuchillos de elefante (controlado por el parámetro LockCount) en la serie, la política ejecuta aún más las siguientes operaciones:

• Llama a la función Update Status para registrar el rango y la información relacionada con el cascarón.
• Usar la función exchange.Buy para comprar un elefante con el precio de compra elephant.Price + PennyTick con el número de compras Lot.
• Comienza un nuevo ciclo ilimitado para la ejecución de pedidos de compra en espera.
• Compruebe el estado de la orden y salte del ciclo si la orden está completa.
• Si el tiempo de espera excede el intervalo de espera establecido, cancele todos los pedidos no completados.
• Se calcula el cambio en los activos de la cuenta después de una compra exitosa, si el cambio es menor a 0.001, indica que la compra ha fracasado, aumenta el número de fracasos y continúa el siguiente ciclo.
• Los registros de los compradores exitosos de plumas de elefante, incluyendo el número de compras.

5. La política continúa en un nuevo ciclo infinito, para la ejecución de la operación de espera de venta. En este ciclo, se ejecutan las siguientes operaciones:

• Para obtener información de profundidad del mercado, comprobar si el precio del mercado ha alcanzado el precio de stop loss.
• Si el precio del mercado ha alcanzado o está por debajo del precio de detención, se realizará una operación de detención, es decir, se venderá el activo restante.
• Llama a la función CancelAll para cancelar todos los pedidos pendientes para reducir el riesgo de almacenamiento.
• Volver a revisar el cambio en los activos de la cuenta después de la compra exitosa, si el cambio es menor a 0.001, significa que la compra ha fracasado y salta del ciclo.
• Por último, se registra el éxito de las transacciones y se actualiza el número de éxitos y de fracasos según el resultado de las transacciones.

La estrategia es una estrategia de trading de alta frecuencia que requiere una rápida respuesta a los cambios en el mercado y que requiere una gestión de riesgos y mecanismos de stop loss para proteger el capital. Los inversores deben considerar cuidadosamente el uso de esta estrategia, especialmente en mercados altamente volátiles.

Las palabras finales

La estrategia Penny Jump es un ejemplo típico de la negociación de alta frecuencia, que muestra el juego y la competencia delicados entre los participantes del mercado. En el mercado de las criptomonedas, esta estrategia es especialmente destacada debido a las grandes fluctuaciones del mercado, tanto los inversores institucionales como los operadores de alta frecuencia que buscan obtener ganancias rápidas. Sin embargo, también hace que el mercado esté lleno de desafíos, que requieren una constante adaptación y ajuste de estrategias para mantener una ventaja competitiva.