Las estrategias de disección de las cosechadoras de colza (2)

Las estrategias de disección de las cosechadoras de colza (2)

EntoncesContenido de arriba hacia atrás¿Qué es lo que está sucediendo?

La tercera función añadida es:

    self.balanceAccount = function() {
        var account = exchange.GetAccount()
        if (!account) {
            return
        }
        self.account = account
        var now = new Date().getTime()
        if (self.orderBook.Bids.length > 0 && now - self.preCalc > (CalcNetInterval * 1000)) {
            self.preCalc = now
            var net = _N(account.Balance + account.FrozenBalance + self.orderBook.Bids[0].Price * (account.Stocks + account.FrozenStocks))
            if (net != self.preNet) {
                self.preNet = net
                LogProfit(net)
            }
        }
        self.btc = account.Stocks
        self.cny = account.Balance
        self.p = self.btc * self.prices[self.prices.length-1] / (self.btc * self.prices[self.prices.length-1] + self.cny)
        var balanced = false
        
        if (self.p < 0.48) {
            Log("开始平衡", self.p)
            self.cny -= 300
            if (self.orderBook.Bids.length >0) {
                exchange.Buy(self.orderBook.Bids[0].Price + 0.00, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.01, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.02, 0.01)
            }
        } else if (self.p > 0.52) {
            Log("开始平衡", self.p)
            self.btc -= 0.03
            if (self.orderBook.Asks.length >0) {
                exchange.Sell(self.orderBook.Asks[0].Price - 0.00, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.01, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.02, 0.01)
            }
        }
        Sleep(BalanceTimeout)
        var orders = exchange.GetOrders()
        if (orders) {
            for (var i = 0; i < orders.length; i++) {
                if (orders[i].Id != self.tradeOrderId) {
                    exchange.CancelOrder(orders[i].Id)
                }
            }
        }
    }

Construcción de funcionesLeeksReaper()Cuando se construye un objeto, se añade a él.balanceAccount()La función es actualizar la información de los activos de la cuenta, almacenarself.accountEs decir, el objeto construido.accountPropiedad:  Calcular el valor de ganancia en tiempo real y imprimirlo  Calcular el porcentaje de saldo de divisas en efectivo (equilibrio de posiciones en efectivo) según la información de los activos de la cuenta más reciente, realizar una liquidación de la pequeña orden para que la moneda (posiciones) vuelva al equilibrio cuando se active el desvío del umbral  Esperar un cierto tiempo de transacción, luego cancelar todos los pedidos suspendidos, ejecutar la función en la siguiente ronda, volver a detectar el equilibrio y hacer el tratamiento correspondiente 

Veamos el código de la función palabra por palabra: Primero la primera frase.var account = exchange.GetAccount()Es una variable local declarada.accountY también se llama a la interfaz API de los inventores.exchange.GetAccount()Función que obtiene los datos más recientes de la cuenta actual y asigna un valor aaccountVariables. Y luego juzgar.accountEsta es una variable que se puede cambiar si la variable esnullEl valor (por ejemplo, fallas en la obtención de problemas de latencia, red, interfaz de intercambio, etc.) se devuelve directamente (corresponde)if (!account){...}Aquí está el video.

self.account = accountEsto es una variante local.accountEs un objeto que se construye.accountLas propiedades se utilizan para registrar la información de la cuenta más reciente en los objetos construidos.

var now = new Date().getTime()Esta frase declara una variable local.nowEn la mayoría de las aplicaciones, la fecha es la fecha de inicio de la llamada.getTime()La función devuelve el tiempo actual.nowLas variables.

if (self.orderBook.Bids.length > 0 && now - self.preCalc > (CalcNetInterval * 1000)) {...}Este código determina la diferencia entre el momento actual y el tiempo de la última vez que se registró si se excede el parámetro.CalcNetInterval * 1000Esto significa que desde la última actualización, ha superado a ahora.CalcNetInterval * 1000MilisegundosCalcNetIntervalLa función de impresión de ganancias en tiempo real se realiza con el precio de compra de una cuenta, ya que el cálculo de ganancias también está limitado en la condición.self.orderBook.Bids.length > 0Esta condición (datos de profundidad, la lista de pagos debe tener información de grado válida). Cuando la condición de la frase if se activa, se ejecutaself.preCalc = nowActualizar las variables de las temporadas de las últimas ganancias de impresiónself.preCalcPara el tiempo actualnowLas estadísticas de ganancias aquí utilizan el método de cálculo del valor neto, codificado comovar net = _N(account.Balance + account.FrozenBalance + self.orderBook.Bids[0].Price * (account.Stocks + account.FrozenStocks))Es decir, el cambio de monedas a dinero ("moneda de facturación") según el precio de compra actual, y luego el número de monedas en la cuenta, sumado a las variables locales que se asignan a la declaración.net◦ Para determinar si el total de la cuenta actual coincide con el total de la cuenta registrada la última vez:

            if (net != self.preNet) {
                self.preNet = net
                LogProfit(net)
            }

Si no coinciden, entoncesnet != self.preNetEn realidad, sí.netActualización de variables para registrar propiedades de valor netoself.preNetY luego imprime esto.netDatos de la netitud total de los inventores en el gráfico de la curva de ganancias de los robots de plataformas de negociación cuantitativas (WEB se puede consultar en la documentación de la API de FMZLogProfitEsta es la función.

Si no se ha activado la ganancia de impresión a tiempo, continúe con el siguiente proceso y se generará un resultado de impresión a tiempo.account.StocksEl número de monedas disponibles en las cuentas corrientesaccount.Balance(Cantidad de dinero disponible en la cuenta corriente) registrado enself.btc，self.cny❖ Calcular el porcentaje de desviación y asignar el registro enself.p。

self.p = self.btc * self.prices[self.prices.length-1] / (self.btc * self.prices[self.prices.length-1] + self.cny)

El algoritmo también es muy simple: calcula el valor actual de la moneda como porcentaje del total neto de la cuenta.

¿Cuándo se determina el equilibrio de las posiciones monetarias? Los autores aquí se basan en un 50% de 2 puntos porcentuales hacia arriba y hacia abajo como un amortiguador, superando el equilibrio de ejecución de la zona de amortiguador, es decir,self.p < 0.48El desvío de la balanza monetaria se desencadena cuando se cree que hay menos monedas, se compra una posición en el mercado y se incrementa el precio 0.01 cada vez que se dispone tres billetes.self.p > 0.52En la actualidad, la mayoría de las personas que se encuentran en el mercado de divisas, no tienen más dinero que pagar.Sleep(BalanceTimeout)Después cancelamos todos los pedidos.

        var orders = exchange.GetOrders()                  # 获取当前所有挂单，存在orders变量
        if (orders) {                                      # 如果获取当前挂单数据的变量orders不为null
            for (var i = 0; i < orders.length; i++) {      # 循环遍历orders，逐个取消订单
                if (orders[i].Id != self.tradeOrderId) {
                    exchange.CancelOrder(orders[i].Id)     # 调用exchange.CancelOrder，根据orders[i].Id取消订单
                }
            }
        }

La cuarta función añadida es:

En la parte central de la estrategia, el gran juego ha llegado.self.poll = function() {...}La función es la lógica principal de toda la estrategia, y en el artículo anterior también hablamos de esto.main()La función se ejecuta y entra.whileAntes del ciclo de la muerte, usamosvar reaper = LeeksReaper()Se construye un objeto de cosechadora de colza y luego se usa en el recolector de colza.main()Llamadas de ciclo en funcionesreaper.poll()Es la función a la que se llama.

self.pollLa función comienza a ejecutarse, hace algunos preparativos antes de cada ciclo, y luego comienza a ejecutarse.self.numTick++¿Qué es lo que está sucediendo?self.updateTrades()Actualizar los registros de transacciones más recientes en el mercado y calcular los datos de uso correspondientes.self.updateOrderBook()Los datos de los registros de facturación se actualizan y se calculan los datos correspondientes.self.balanceAccount()En el caso de las monedas, el saldo de las monedas (positiones) es el siguiente:

        var burstPrice = self.prices[self.prices.length-1] * BurstThresholdPct   # 计算爆发价格
        var bull = false             # 声明牛市标记的变量，初始为假
        var bear = false             # 声明熊市标记的变量，初始为假
        var tradeAmount = 0          # 声明交易数量变量，初始为0

El próximo paso es juzgar si el mercado corto es un toro o un oso.

        if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -1)) > burstPrice ||
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -2)) > burstPrice && self.prices[self.prices.length-1] > self.prices[self.prices.length-2]
            )) {
            bull = true
            tradeAmount = self.cny / self.bidPrice * 0.99
        } else if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -1)) < -burstPrice ||
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -2)) < -burstPrice && self.prices[self.prices.length-1] < self.prices[self.prices.length-2]
            )) {
            bear = true
            tradeAmount = self.btc
        }

¿Recuerdan el artículo anterior?self.updateOrderBook()¿Qué es una función en la que usamos un algoritmo de media ponderada para construir una secuencia de tiempo en orden?pricesArreglos. En este código se utilizan tres nuevas funciones._.min，_.max，sliceLas tres funciones también son muy comprensibles.

• _.minLa función : es el valor más pequeño de la matriz de parámetros que se busca.

• _.maxLa función : es buscar el valor más grande de la matriz de parámetros.

• slice: es una función miembro de un objeto de matriz JavaScript que devuelve una parte de la matriz recortada por el índice, por ejemplo:

  function main() {
      // index     .. -8 -7 -6 -5 -4 -3 -2 -1
      var arr = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
      Log(arr.slice(-5, -1))    // 会截取 4 ~ 1 这几个元素，返回一个新数组：[4,3,2,1]
  }
  

  

En este caso, los criterios para juzgar a un oso o una vaca son:

• self.numTick > 2Para establecerse, es decir, cuando una nueva ronda de precios de detección estalle, se debe activar después de al menos tres rondas de detección, evitando activar desde el principio.
• Secuencias de preciosself.pricesEl último dato, que es el más reciente,self.pricesHay que romper la diferencia de precio entre el máximo o el mínimo en el rango anterior de la matrizburstPriceEl precio de este estallido.

Si todas las condiciones se cumplen, marquebull¿Qué es esto?bear¿Por qué?trueY también paratradeAmountLos cambios en el valor de las variables, la planificación de transacciones hip hop.

¿Qué es lo que está pasando?self.updateTrades()Actualización, cálculo de las funcionesself.volPara los parámetrosBurstThresholdVolDecidir si reducir la intensidad de las transacciones ("reducir el volumen de las transacciones planificadas").

        if (self.vol < BurstThresholdVol) {
            tradeAmount *= self.vol / BurstThresholdVol   // 缩减计划交易量，缩减为之前量的self.vol / BurstThresholdVol 倍
        }
        
        if (self.numTick < 5) {
            tradeAmount *= 0.8      // 缩减为计划的80%
        }
        
        if (self.numTick < 10) {    // 缩减为计划的80%
            tradeAmount *= 0.8
        }

El siguiente paso es evaluar si las señales de transacción o el volumen de transacción cumplen con los requisitos:

        if ((!bull && !bear) || tradeAmount < MinStock) {   # 如果非牛市并且也非熊市，或者计划交易的量tradeAmount小于参数设置的最小交易量MinStock，poll函数直接返回，不做交易操作
            return
        }

Después de haber tomado la decisión anterior, ejecutarvar tradePrice = bull ? self.bidPrice : self.askPriceEl precio de la transacción se establece según el mercado oscuro o el mercado de los toros, y se asigna el precio correspondiente al pedido.

Y finalmente entró en uno.whileLa única condición para que el ciclo se detenga estradeAmount >= MinStockLa cantidad de transacciones programadas es menor que la cantidad mínima. En el ciclo, se ejecuta la siguiente orden según el estado actual del mercado de los toros o del mercado de los osos; y se registra un solo ID en la variableorderId◎ Después de cada ciclo de pedidoSleep(200)Espere 200 ms. y luego juzgue en el ciclo.orderId¿Es verdad (si el pedido falla y no devuelve el ID del pedido, no se activará la condición if), si la condición es verdad.self.tradeOrderId。

Declare una variable para almacenar datos de pedidosorderLa asignación inicial esnullLuego, el ciclo obtiene los datos de la orden de este ID y decide si la orden está en estado de suspensión, si está en estado de suspensión, cancela la orden de este ID, si no está en estado de suspensión, salta el ciclo de detección.

                var order = null           // 声明一个变量用于保存订单数据
                while (true) {             // 一个while循环
                    order = exchange.GetOrder(orderId)    // 调用GetOrder查询订单ID为 orderId的订单数据
                    if (order) {                          // 如果查询到订单数据，查询失败order为null，不会触发当前if条件
                        if (order.Status == ORDER_STATE_PENDING) {   // 判断订单状态是不是正在挂单中
                            exchange.CancelOrder(orderId)            // 如果当前正在挂单，取消该订单
                            Sleep(200)
                        } else {                                     // 否则执行break跳出当前while循环
                            break
                        }
                    }
                }

Luego, ejecuta el siguiente proceso:

                self.tradeOrderId = 0              // 重置self.tradeOrderId
                tradeAmount -= order.DealAmount    // 更新tradeAmount，减去提单的订单已经成交的数量
                tradeAmount *= 0.9                 // 减小下单力度
                if (order.Status == ORDER_STATE_CANCELED) {     // 如果订单已经是取消了
                    self.updateOrderBook()                      // 更新订单薄等数据
                    while (bull && self.bidPrice - tradePrice > 0.1) {   // 牛市时，更新后的提单价格超过当前交易价格0.1就减小交易力度，略微调整交易价格
                        tradeAmount *= 0.99
                        tradePrice += 0.1
                    }
                    while (bear && self.askPrice - tradePrice < -0.1) {  // 熊市时，更新后的提单价格超过当前交易价格0.1就减小交易力度，略微调整交易价格
                        tradeAmount *= 0.99
                        tradePrice -= 0.1
                    }
                }

Cuando el proceso se saltawhile (tradeAmount >= MinStock) {...}En este ciclo, se indica que el proceso de ejecución de la transacción de explosión de precios ha terminado. Ejecuciónself.numTick = 0Es decir, reubicar.self.numTickEs 0.

LeeksReaper()La ejecución de la función constructor será final.selfEl objeto regresa, es decirvar reaper = LeeksReaper()En el momento en que se le devuelve.reaper。

Hasta ahoraLeeksReaper()Hemos analizado una vez más cómo se construyen las funciones de construcción de este objeto de cosechadora de colza y los diferentes métodos de ejecución de los objetos de cosechadora de colza, las principales funciones lógicas, y creo que después de leer este artículo debería tener una comprensión más clara de este proceso de algoritmo de estrategia de alta frecuencia.