1. Carré
  2. Transfert de la grille de contrats bidirectionnelle v1.0.2

Transfert de la grille de contrats bidirectionnelle v1.0.2

Auteur:le vent, Date: le 24 juin 2021 à 15h37
Les étiquettes:Réseau

Transfert de la grille de contrats bidirectionnelle v1.0.2

Fonction

Traitements de grille Il y a aussi une différence de prix grâce à l'augmentation du temps de travail. Le risque d'un effondrement de la stratégie bidirectionnelle est très faible.

  • Les acheteurs ont décidé d'acheter en retard.
  • Le doublement
  • Compte automatique
  • Les tendances sont ouvertes (en cours de développement, version payante)
  • Taux de baisse dynamique modifier le nombre de commandes (en cours de développement, version payante)
  • La tendance à la fourchette en or s'est jointe (en cours de développement, version payante)

Les données de retouche

img

img

Deux fois plus en six mois Les bénéfices sont évidents, les hausses et les baisses peuvent être prises en compte.

Maintenance

Optimisation continue


/*backtest
start: 2021-01-01 00:00:00
end: 2021-06-21 23:59:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT","balance":2000}]
*/

// 首次买入
let FIRST_BUY = true;
// 已存在买涨订单
let MANY_BUYING = false;
// 已存在做空订单
let SHORT_BUYING = false;
// 买涨订单创建时间
let MANY_BUY_TIME = null;
// 做空订单创建时间
let SHORT_BUY_TIME = null;
// 买涨空仓时间
let MANY_EMPTY_STEP_TIME = null;
// 做空空仓时间
let SHORT_EMPTY_STEP_TIME = null;
// 校验空仓时间
let CHECK_TIME = null;

let QUANTITY = [0.001, 0.002, 0.004, 0.008, 0.016, 0.032, 0.064];
// 下次购买价格(多仓)
let MANY_NEXT_BUY_PRICE = 0;
// 下次购买价格(空仓)
let SHORT_NEXT_BUY_PRICE = 0;
// 当前仓位(多仓)
let MANY_STEP = 0;
// 当前仓位(空仓)
let SHORT_STEP = 0;
// 止盈比率
let PROFIT_RATIO = 1;
// 补仓比率
let DOUBLE_THROW_RATIO = 1.5;
// 卖出后下次购买金额下浮比率
let BUY_PRICE_RATIO = 1;
// 交易订单列表(多仓)
let MANY_ORDER_LIST = [];
// 交易订单列表(空仓)
let SHORT_ORDER_LIST = [];

function getManyQuantity() {
    if (MANY_STEP < QUANTITY.length) {
        return QUANTITY[MANY_STEP]
    }
    return QUANTITY[0]
}

function getShortQuantity() {
    if (SHORT_STEP < QUANTITY.length) {
        return QUANTITY[SHORT_STEP]
    }
    return QUANTITY[0]
}

function firstManyBuy(ticker) {
    if (MANY_BUYING) {
        return
    }
    exchange.SetDirection("buy")
    let orderId = exchange.Buy(ticker.Last, getManyQuantity())
    if (!orderId) {
        return
    }
    MANY_BUYING = true
    while (true) {
        exchange.SetDirection("buy") 
        let order = exchange.GetOrder(orderId)
        if (null === order) {
            continue
        }
        if (1 === order.Status || 2 === order.Status) {
            MANY_NEXT_BUY_PRICE = order.Price * ((100 - DOUBLE_THROW_RATIO) / 100)
            MANY_STEP = MANY_STEP + 1
            MANY_BUYING = false
            MANY_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 + PROFIT_RATIO) / 100)
            MANY_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
    }
}

function firstShortBuy(ticker) {
    if (SHORT_BUYING) {
        return
    }
    exchange.SetDirection("sell")
    let orderId = exchange.Sell(ticker.Last, getShortQuantity())
    if (!orderId) {
        return
    }
    SHORT_BUYING = true
    while (true) {
        let order = exchange.GetOrder(orderId)
        if (null === order) {
            continue
        }
        if (1 === order.Status || 2 === order.Status) {
            SHORT_NEXT_BUY_PRICE = order.Price * ((100 + DOUBLE_THROW_RATIO) / 100)
            SHORT_STEP = SHORT_STEP + 1
            SHORT_BUYING = false
            SHORT_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 - PROFIT_RATIO) / 100)
            SHORT_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
    }
}

function manyBuy(ticker) {
    if (MANY_BUYING) {
        return
    }
    Log('ticker: ' + ticker.Last + ' MANY_NEXT_BUY_PRICE: ' + MANY_NEXT_BUY_PRICE)
    if (ticker.Last > MANY_NEXT_BUY_PRICE) {
        return
    }
    exchange.SetDirection("buy")
    let orderId = exchange.Buy(ticker.Last, getManyQuantity())
    if (!orderId) {
        return
    }
    MANY_BUYING = true
    MANY_BUY_TIME = Unix()
    while (true) {
        let now = Unix()
        let order = exchange.GetOrder(orderId)
        let expire = MANY_BUY_TIME + (60 * 30)
        if (null === order) {
            continue
        }
        // 买入成功处理
        if (1 === order.Status || 2 === order.Status) {
            MANY_NEXT_BUY_PRICE = order.Price * ((100 - DOUBLE_THROW_RATIO) / 100)
            MANY_STEP = MANY_STEP + 1
            MANY_BUYING = false
            MANY_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 + PROFIT_RATIO) / 100)
            MANY_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
        // 买入超时处理
        if (now >= expire) {
            exchange.CancelOrder(orderId)
            MANY_BUYING = false
            MANY_BUY_TIME = null
            MANY_NEXT_BUY_PRICE = ticker.Last * ((100 - DOUBLE_THROW_RATIO) / 100)
            return
        }
    }
}

function shortBuy(ticker) {
    if (SHORT_BUYING) {
        return
    }
    Log('ticker: ' + ticker.Last + ' SHORT_NEXT_BUY_PRICE: ' + SHORT_NEXT_BUY_PRICE)
    if (ticker.Last < SHORT_NEXT_BUY_PRICE) {
        return
    }
    exchange.SetDirection("sell")
    let orderId = exchange.Sell(ticker.Last, getShortQuantity())
    if (!orderId) {
        return
    }
    SHORT_BUYING = true
    SHORT_BUY_TIME = Unix()
    while (true) {
        let now = Unix()
        let expire = SHORT_BUY_TIME + (60 * 30)
        let order = exchange.GetOrder(orderId)
        if (null === order) {
            continue
        }
        // 买入成功处理
        if (1 === order.Status || 2 === order.Status) {
            SHORT_NEXT_BUY_PRICE = order.Price * ((100 + DOUBLE_THROW_RATIO) / 100)
            SHORT_STEP = SHORT_STEP + 1
            SHORT_BUYING = false
            SHORT_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 - PROFIT_RATIO) / 100)
            SHORT_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
        // 买入超时处理
        if (now >= expire) {
            exchange.CancelOrder(orderId)
            SHORT_BUYING = false
            SHORT_BUY_TIME = null
            SHORT_NEXT_BUY_PRICE = ticker.Last * ((100 + DOUBLE_THROW_RATIO) / 100)
            return
        }
    }
}


function manySell(ticker) {
    // 遍历卖出订单
    for (let item of MANY_ORDER_LIST) {
        if (item.isSell) {
            continue
        }
        if (ticker.Last >= item.sellPrice) {
            item.isSell = true;
            exchange.SetDirection("closebuy")
            let orderId = exchange.Sell(ticker.Last, item.quantity)
            if (!orderId) {
                return
            }
            while (true) {
                let order = exchange.GetOrder(orderId)
                if (null === order) {
                    continue
                }
                if (1 === order.Status || 2 === order.Status) {
                    MANY_NEXT_BUY_PRICE = ticker.Last * ((100 - BUY_PRICE_RATIO) / 100)
                    MANY_STEP = MANY_STEP - 1
                    if (0 === MANY_STEP) {
                        MANY_EMPTY_STEP_TIME = Unix()
                    }
                    break
                }
            }
        }
    }
}

function shortSell(ticker) {
    // 遍历卖出订单
    for (let item of SHORT_ORDER_LIST) {
        if (item.isSell) {
            continue
        }
        if (ticker.Last <= item.sellPrice) {
            item.isSell = true;
            exchange.SetDirection("closesell")
            let orderId = exchange.Buy(ticker.Last, item.quantity)
            if (!orderId) {
                return
            }
            while (true) {
                let order = exchange.GetOrder(orderId)
                if (null === order) {
                    continue
                }
                if (1 === order.Status || 2 === order.Status) {
                    SHORT_NEXT_BUY_PRICE = ticker.Last * ((100 + BUY_PRICE_RATIO) / 100)
                    SHORT_STEP = SHORT_STEP - 1
                    if (0 === SHORT_STEP) {
                        SHORT_EMPTY_STEP_TIME = Unix()
                    }
                    break
                }
            }
        }
    }
}

function check(ticker) {
    let now = Unix()
    if (null !== CHECK_TIME) {
        let expire = CHECK_TIME + (60 * 10)
        if (now < expire) {
            return
        }
    }
    CHECK_TIME = now

    if (null !== MANY_EMPTY_STEP_TIME) {
        let expire = MANY_EMPTY_STEP_TIME + (60 * 30)
        if (now >= expire) {
            MANY_NEXT_BUY_PRICE = ticker.Last * ((100 - DOUBLE_THROW_RATIO) / 100)
            Log('没有买涨持仓, 调整买入价: ' + MANY_NEXT_BUY_PRICE)
        }
    }
    
    if (null !== SHORT_EMPTY_STEP_TIME) {
        let expire = SHORT_EMPTY_STEP_TIME + (60 * 30)
        if (now >= expire) {
            SHORT_NEXT_BUY_PRICE = ticker.Last * ((100 + DOUBLE_THROW_RATIO) / 100)
            Log('没有做空持仓, 调整买入价: ' + SHORT_NEXT_BUY_PRICE)
        }
    }
}

function onTick() {
    // 在这里写策略逻辑，将会不断调用，例如打印行情信息
    let ticker = exchange.GetTicker()
    if (!ticker) {
        return
    }
    if (FIRST_BUY) {
        // 首次做多购买
        firstManyBuy(ticker)
        // 首次做空购买
        firstShortBuy(ticker)
        FIRST_BUY = false
        return
    }
    
    // 做多买入
    manyBuy(ticker)
    // 做空买入
    shortBuy(ticker)
    // 做多卖出
    manySell(ticker)
    // 做空卖出
    shortSell(ticker)
    // 空仓检测
    check(ticker)
}

function main() {
    // 开合约
    exchange.SetContractType("swap")

    while(true){
        onTick()
        // Sleep函数主要用于数字货币策略的轮询频率控制，防止访问交易所API接口过于频繁
        Sleep(60000)
    }
}
Relationnée
Plus de

Il est en train de mourir.Est-il possible d'avoir plusieurs devises?

Je suis riche.Quel est le sens de ce terme? ==============================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================

artronPourquoi n'y a-t-il pas de paramètre de stratégie?

Le film a été réalisé par le réalisateur et réalisateur de la série.En outre, le test ETH s'arrêterait au 1-2 lors du test 2021-1-1 à 201-6-21, je ne sais pas si c'est un problème de fmz ou un problème de robot.

Je suis Evan.Ce n'est pas une vraie couverture multi-espaces, c'est comme une grille de contrats.

Le film a été réalisé par le réalisateur et réalisateur de la série.Nous n'avons reçu aucune réponse, nous n'avons pu venir ici que pour dire quelques phrases, nous avons été opérationnels pendant 7 jours, 200 couteaux en or et 70 couteaux en or. C'était très bien, mais j'ai découvert quelques problèmes au cours de l'opération. 1. la fonction d'ouverture à double sens est-elle normale? voir la stratégie dit que le billet à double sens, la probabilité d'explosion est très faible, mais en sept jours, en plus du robot a commencé à ouvrir à double sens, il n'y a pratiquement pas de billet à double sens, après ma recherche, j'ai constaté que 10 minutes de mise à jour une position de l'ouverture, ce qui entraîne des changements plus lents, cela n'a pas de sens, ni l'ouverture à double sens, par exemple, aujourd'hui, la baisse de 5% de BTC aujourd'hui n'a pas été ouverte. Pour ce qui est de l'augmentation de capital par défaut, je ne veux pas que l'augmentation de capital soit nécessaire pour assurer le financement de 1000 ou 2000 ou plus de couteaux, j'ai 200 couteaux aujourd'hui si je ne me réveille pas de façon inattendue, j'ai déjà augmenté l'augmentation de capital, une garantie provisoire. Si les fonds ne sont pas suffisants, vous pouvez également ajuster manuellement le nombre d'augmentations de capital, rappelez-moi ici, pour ne pas voir l'augmentation de capital du code. 3. S'il vous plaît, demandez-moi, parce que les pertes ne s'arrêtent jamais, alors si le capital est suffisant, ne sera-t-il jamais exploser, mais pourquoi y aura-t-il des pertes dans la réévaluation? Cette stratégie que j'aime beaucoup, vous pouvez profiter indépendamment de la direction, ajuster le montant de l'augmentation et le risque de l'explosion de capital, le sentiment d'ajuster le prix de l'ouverture et de l'excès peut être optimisé, en fonction de l'ajout de capital de l'ajustement du montant de l'augmentation, etc.

OuiXMon frère a envoyé un message

Le film a été réalisé par le réalisateur et réalisateur de la série.C'est résolu, le bitcoin fonctionne.

Le film a été réalisé par le réalisateur et réalisateur de la série.Le champ de volume est illégal. S'il vous plaît ré-entrer. status:error ts:1.625132342294e+12].

leIl n'y a pas de disque?

Le film a été réalisé par le réalisateur et réalisateur de la série.C'est terrible, cette courbe de gains, c'est une perte de plus de 120%.

Je suis ivre, je prends ma lampe et je regarde mon épée.Je me suis moqué de lui.

Le film a été réalisé par le réalisateur et réalisateur de la série.Malheureusement, aujourd'hui, nous avons perdu, nous sommes impatients de voir 2.0, mais comment pouvons-nous expérimenter cette nouvelle stratégie?

le ventNous avons découvert ces problèmes dans la version 2.0 du développement. La raison pour laquelle les échanges négatifs ne peuvent pas être achetés est que le pourcentage d'ouverture est fixe, c'est-à-dire une hausse de 1%, un échange négatif, une baisse de 1%, un échange négatif. Comme la chute est de 1%, la chute est le même pourcentage d'achat, de 1 000 tonnes à 1 500 tonnes, 1 000 pour cent et 1 500 pour cent ne sont pas les mêmes, il est plus difficile d'acheter des carreaux et les prix changent trop fréquemment, ce qui rend les carreaux plus susceptibles de ne pas être achetés. Le problème du stop-loss, dans la version 2.0, a fait un certain traitement, un traitement de stop-loss très simple, mais d'après les données de retouche, l'effet peut encore être, lorsque vous achetez des pièces ou que vous faites des positions vides, lorsque vous atteignez un certain seuil, le stock entier commence à être vendu, 1.0 n'est pas traité, donc il y a des commandes qui ne peuvent jamais être traitées, par exemple, sur BTC 65000 le nombre de acheteurs 0.001, alors BTC est tombé cette liste ne peut jamais sortir. /upload/asset/2034c4ec56c423120b9c6.png /upload/asset/203032c94e60a3915cc9f.png /upload/asset/2030b880b030476977f4b.png /upload/asset/2030d89e9fd59f528be4c.png Le contenu du fichier est en anglais seulement.

le ventJ'ai testé le disque virtuel en cours d'exécution avec Binance, d'autres plates-formes pourraient signaler des erreurs.

le ventLe disque est toujours en marche, il faut du temps

le ventRegardez la dernière courbe, il y a un bug dans la précédente.

2019 FMZ - Tous les droits réservés