Les modules visualisés construisent des stratégies de transaction - progressivement

Les modules de visualisation pour créer des stratégies de transactions sont en cours de développement

Apprendre à construire des stratégies de transaction avec des modules visualisés est une première étape, une compréhension conceptuelle de la construction et de l'assemblage des modules visualisés est nécessaire. Il est plus facile d'apprendre à utiliser d'autres modules. Il est possible de combiner des fonctionnalités plus complexes.

• Module de catégorie de transaction

  Dans les études et les tests précédents, nous avons abordé plusieurs modules de "catégories de transactions". Par exemple: Le module "Acquérir des marchés" Module "Les échanges acquièrent les lignes K" Je ne sais pas.

  Les utilisateurs de Twitter ne sont pas les seuls à utiliser ces outils.

  • 1°, obtenir le nombre d'échanges

    

    Lors de la rédaction d'une stratégie utilisant un robot de trading, il est possible d'ajouter plus d'un objet d'échange, comme une stratégie de couverture. Il peut être nécessaire de parcourir (parcourir signifie visiter une fois par une fois) l'objet de l'échange, pour visiter le marché. Il est donc nécessaire d'utiliser des modules pour obtenir le nombre d'échanges.

    Nous pouvons d'abord imprimer le nombre d'échanges actuellement configurés en utilisant une structure simple:

    Il s'agit en fait d'appeler le code de stratégie JavaScript suivant:

    function main () {
        Log(exchanges.length)
    }
    

    Voici les résultats de cette combinaison de modules:

    Vous pouvez voir que nous avons ajouté 3 objets d'échange, représentant trois comptes d'échange différents, et que le résultat de la réévaluation des journaux est 3.

  • 2° Obtenir le nom de l'échange

    

    Lorsque vous ajoutez trois objets d'échange, la barre de bas de page affiche trois options. Apprendre un module de cycle à l'avance, dans le type de cycle.

    Il y a aussi un module de conditionnement à apprendre à l'avance:Les conditions peuvent être écrites comme suit:

    Nous avons ajouté le nom de l'échange en utilisant le module circulaire. Le module de jugement conditionnel est utilisé pour déterminer si le nombre de cycles actuel correspond au nom de l'échange à imprimer.

    

    Les résultats de la reprise:

    Par exemple, le code de stratégie JavaScript:

    function main () {
        for (var i = 1 ; i <= exchanges.length ; i++) {
            if (i == 1) {
                Log(exchanges[0].GetName())
            } else if (i == 2) {
                Log(exchanges[1].GetName())
            } else {
                Log(exchanges[2].GetName())
            }
        }
    }
    

  • 3° Obtenir les paires de transactions en cours sur l'échange

    

    Un exemple simple est d'obtenir la première paire de transactions de l'objet de l'échange dans la configuration actuelle et d'attribuer une valeur à la variable text (crée à l'avance dans la catégorie des variables).

    Les résultats des tests:

    Si vous appelez le code de stratégie JavaScript:

    function main () {
        var text = exchange.GetCurrency()
        Log(text)
    }
    

  • 4 modules de sous-rubrique

    Le module est très important pour les opérations de commande, la première position de la souris () est intégrée à la variable de prix, pour spécifier le prix de la commande, ou pour entrer directement des valeurs fixes. La deuxième position de la souris () est intégrée à la variable de la quantité à commander, pour spécifier la quantité à commander.

    Par exemple, nous avons composé un exemple de paiement à partir du prix le plus récent basé sur les données de transaction de tick actuelles, plus 10 dollars de prix glissant, la quantité de la commande est réglée à 0,1 pièce et l'ID de l'ordre est imprimé.

    Les résultats de la reprise:

    Par exemple, le code de stratégie JavaScript suivant:

    function main () {
        var id = exchange.Buy(_C(exchange.GetTicker).Last + 10, 0.1)
        Log(id)
    }
    

  • 5° Obtenir les modules des transactions en cours sur les commandes de commande

    

    Le module renvoie tous les ordres de commande dans l'état d'une paire de transactions en cours qui n'est pas terminée, et renvoie une structure de liste (une matrice) qui peut être traitée avec un module de type liste (une opération de parcours, etc.). Par exemple: nous avons modifié un peu le modèle de module de vente au détail ci-dessus, en changeant le prix de 10 $ ajouté au moment de la commande en moins de 10 $. L'ordre ne sera pas immédiatement traité, mais sera suspendu à la profondeur de vente (c'est-à-dire à un certain niveau dans un achat, un achat, un achat N), de sorte que l'ordre est dans un état de vente au détail en attente de traitement. Ensuite, nous utilisons le module " Obtenir les commandes en attente d'une transaction " pour obtenir une liste des commandes en attente d'une transaction. Afin d'éviter que la transaction des commandes dans les transactions ultérieures n'affecte les dernières observations de la réévaluation, nous avons imprimé une liste d'ordres après l'exécution du module " Obtenir la transaction en cours sur l'ordre de commande " et immédiatement arrêté le processus à l'aide du module " Jeter une exception ".

    

    Les résultats de cette analyse montrent:

    Le prix de la prochaine commande est inférieur au prix actuel de 10 dollars, donc il n'y aura pas de transaction immédiate. Les commandes en attente sont ensuite récupérées et imprimées. La dernière chose à faire est de jeter une exception et d'arrêter le programme.

    Les modules sont assemblés comme s'ils appelaient une stratégie JavaScript:

    function main () {
        var id = exchange.Buy(_C(exchange.GetTicker).Last - 10, 0.1)
        Log(id)
        Log(exchange.GetOrders())
        throw "stop"
    }
    

  • 6, annuler les modules de commande

    

    Le module est utilisé pour annuler les commandes.

    Il y a beaucoup de scénarios qui nécessitent une telle opération lors de l'écriture d'une stratégie:

    Nous avons décidé de supprimer toutes les commandes actuellement en attente.

    Il est certain que cela nécessite l'utilisation d'un "module de retrait", et en même temps que l'apprentissage du module de retrait, nous pouvons utiliser le module d'acquisition de la transaction en cours par ordre de commande avec le module de retrait de la combinaison de 5 pour réaliser cette fonctionnalité.

    Tout d'abord, pour tester l'annulation de toutes les commandes, il n'est pas évident de suspendre une seule commande, nous commençons à commander deux fois et le nombre de prix est différent pour distinguer les deux commandes.

    

    Utilisez le module "Passez par chaque élément de la liste" dans le module de type de cycle pour parcourir les commandes de la liste de listes en cours.Lors de l'exploration, chaque ordre extrait est attribué à un module de variable order ((crée dans le type de module de variable, comme illustré ci-dessous:)Dans le module de type d'outil:Retirer l'ID de l'ordre, le transmettre à l'emplacement de l'ordre de révocation et exécuter l'ordre de révocation.

    Le dépistage est en cours:

    Décrire en utilisant la stratégie JavaScript:

    function main () {
        var id = exchange.Buy(_C(exchange.GetTicker).Last - 10, 0.1)
        Log(id)
        var id2 = exchange.Buy(_C(exchange.GetTicker).Last - 12, 0.2)
        Log(id2)
        var orders = exchange.GetOrders()
        Log(orders)
        for (var i in orders) {
            var order = orders[i]
            Log(exchange.CancelOrder(order.Id))
        }
    }
    

  • 7. Module pour obtenir les détails d'une commande en fonction de l'ID de commande

    

    Le module est positionné sur un module d'accès à une variable d'identification d'ordre pour retourner les détails de l'ordre.

    

    Les commandes qui ont été retournées après le lancement:

    Une comparaison des résultats de l'expérience de fonctionnement avec le 5 tonnes de soupape montre que l'ordre imprimé est un message d'ordre distinct, sans[]Les parenthèses sont dans le paquet. L'exemple du module 5 est une liste, ce modèle renvoie un message d'ordre séparé (obtention d'une variable ID basée sur la position du module dans lequel le module est passé).

    Les exemples ci-dessus sont les mêmes que ceux utilisés pour exécuter une stratégie JavaScript:

    function main () {
        var id = exchange.Buy(_C(exchange.GetTicker).Last - 10, 0.1)
        Log(exchange.GetOrder(id))
    }
    

  • Module de négociation de contrats à terme

    Les modules ci-dessus, nous les apprenons un par un, et nous testons les échanges que nous avons mis en place pour les contrats à terme sur produits.

    Réglage des paramètres:Les exemples suivants sont des tests de retouche basés sur ce paramètre.

    • Déterminez le module d'état de connexion des serveurs des futures de produits CTP et des futures de sociétés

      

      Les contrats à terme sur les produits ont des heures d'ouverture et des heures d'arrêt.

    • Mettre en place un module de contrat

      

      Lorsque l'objet de l'échange est configuré comme un échange à terme, l'erreur se produit lorsque le marché est consulté directement sans avoir mis en place de contrat:

      Nous avons mis en place un contrat pour MA909, et le méthanol est le principal contrat actuellement.Cela permet d'obtenir la valeur actuelle du prix de la tique actuelle du contrat MA909.

    • Mettre en place des modules unidirectionnels pour les contrats à terme

      Exécution des sous-modules
      Il est nécessaire de spécifier une direction unique, car les contrats à terme ont: acheter: faire plus d'actions Vendre: stockage ouvert closebuy: le plus grand nombre possible closesell: stockage à plat Quatre directions (les contrats à terme sur les produits sont ajoutés à deux autres directions: closebuy_today, closeesell_today, et closebuy_today).

      Par exemple, si vous définissez le module de sous-traitance comme un achat, il y a deux significations, le stockage en plus et le stockage en moins, ce qui produit une binalité. Il est donc nécessaire de configurer une direction de négociation des contrats à terme pour définir une direction de négociation claire.

      

      Les résultats montrent:

      Par exemple, le code de stratégie JavaScript:

      function main () {
          while (true) {
              if (exchange.IO("status")) {
                  exchange.SetContractType("MA909")
                  Log(exchange.GetTicker().Last)
                  exchange.SetDirection("buy")
                  Log(exchange.Buy(1000, 1))
                  throw "stop"
              } else {
                  Log("未连接商品期货前置机")
              }
              Sleep(1000)
          }
      }
      

  • 9. Module de négociation de contrats à terme pour la monnaie numérique

    L'utilisation des futures de crypto-monnaie est essentiellement la même que celle des futures de produits dans les huit catégories ci-dessus.

    • Le code du contrat peut être:

      • this_week: Cette semaine
      • Next_week: La semaine suivante
      • Quartier: Quartier
      • Swap: Persistant

    • BitMEX:

      • XBTUSD
      • ETHUSD

    • Mettre en place le module de levier

      

      Les utilisateurs peuvent utiliser des outils similaires pour créer un effet de levier sur les devises numériques.

      # 注意 ： 回测不支持。
      

      Il y a des stratégies de JavaScript comme:

      function main () {
          exchange.SetMarginLevel(10)
      }
      

Une stratégie de visualisation de paradigmes:

• https://www.fmz.com/strategy/121404
• https://www.fmz.com/strategy/129895
• https://www.fmz.com/strategy/123904
• https://www.fmz.com/strategy/122318

Pour plus de détails, consultez:https://www.fmz.com/square

Autres articles dans cette série

• Les modules visualisés construisent des stratégies de transaction - en profondeur
• Les modules visualisés construisent des stratégies de transaction - une idée de base

C'est un programme ennuyeux, qui peut être facilement fait avec des blocs, essayez-le vous-même, c'est très amusant!