[TOC]

Tutoriel d’introduction au langage quantitatif PINE d’Inventor

Le tutoriel vidéo: Comment faire pour entrer dans le commerce quantique?

La plate-forme de trading quantique de l’inventeur prend en charge les stratégies d’écriture du langage Pine, prend en charge les stratégies de retour de données et de fonctionnement en direct du langage Pine, et est compatible avec les versions inférieures du langage Pine.Place de la stratégieIl y a beaucoup de stratégies et de scripts de Pine qui ont été collectés et transférés.

FMZ ne prend pas seulement en charge le langage Pine, mais également la fonctionnalité de dessin puissante du langage Pine. Les fonctionnalités de la plate-forme FMZ, les outils pratiques et la gestion efficace et facile, améliorent encore la fonctionnalité de la stratégie et du script de Pine. FMZ est basé sur la compatibilité avec le langage Pine, mais a également un certain degré d’extension, d’optimisation et de coupe.

Voici un bref aperçu de certaines des différences les plus évidentes:

• 1 Politique de Pine sur FMZ, version identifiée au début du code//@versionet le code commence parstrategy、indicatorLes phrases ne sont pas obligatoires et FMZ ne les prend pas en charge pour le moment.importImportélibraryfonction.

Vous pouvez voir des stratégies comme celle-ci:

  //@version=5
  indicator("My Script", overlay = true)
  src = close
  a = ta.sma(src, 5)
  b = ta.sma(src, 50)
  c = ta.cross(a, b)
  plot(a, color = color.blue)
  plot(b, color = color.black)
  plotshape(c, color = color.red)

Ou comme ceci:

  //@version=5
  strategy("My Strategy", overlay=true)

  longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
  if (longCondition)
      strategy.entry("My Long Entry Id", strategy.long)

  shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))
  if (shortCondition)
      strategy.entry("My Short Entry Id", strategy.short)

La FMZ peut être simplifiée comme suit:

  src = close
  a = ta.sma(src, 5)
  b = ta.sma(src, 50)
  c = ta.cross(a, b)
  plot(a, color = color.blue, overlay=true)
  plot(b, color = color.black, overlay=true)
  plotshape(c, color = color.red, overlay=true)

Ou encore:

  longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
  if (longCondition)
      strategy.entry("My Long Entry Id", strategy.long)

  shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))
  if (shortCondition)
      strategy.entry("My Short Entry Id", strategy.short)

• 2 , Stratégie (script) Certains paramètres liés aux transactions sont définis par le paramètre “Pine language transaction class library” de l’interface de stratégie FMZ.

  • Modèles de clôture et de prix en temps réel Dans la vue commerciale, nous pouvons passer parstrategyLa fonctioncalc_on_every_tickParamètre pour définir la stratégie Le script exécute la logique de la stratégie en temps réel à chaque changement de prix, à ce moment-làcalc_on_every_tickLe paramètre doit être défini surtruePar défautcalc_on_every_tickLe paramètre estfalseLa logique de la stratégie n’est exécutée que lorsque la ligne KBAR de la stratégie est terminée. Sur FMZ, les paramètres sont définis à l’aide du modèle de la bibliothèque de classes “Pine Language Exchange”.

  

  • La précision des valeurs telles que le prix à l’exécution de la stratégie, la quantité de commande suivante, etc., doit être contrôlée sur la FMZ. Dans la vue de trading, il n’y a pas de problème de précision lors de la commande en temps réel car il n’y a que des tests d’analogie. Sur la FMZ, il est possible d’exécuter la stratégie Pine en temps réel.

  • Code du contrat à terme La variété de transaction sur FMZ, si elle est un contrat, a 2 attributs: “paire de transaction” et “code de contrat”. En plus d’avoir besoin de définir clairement la paire de transaction en temps réel et en temps réel, il est également nécessaire de définir un code de contrat spécifique dans le paramètre “code de variété” du modèle de la bibliothèque de transactions en langage Pine. Par exemple, pour les contrats à perpétuité, remplissezswapLe code du contrat dépend de l’échange sur lequel vous opérez. Par exemple, vous pouvez remplir le code de tous les contrats trimestriels de certaines transactions.quarterLes codes de ces contrats correspondent à ceux définis dans la documentation de l’API Javascript/python/c++ de FMZ.

Pour d’autres paramètres, tels que le nombre minimum de commandes, le nombre par défaut de commandes, etc., voir la documentation de la langue Pine surUne bibliothèque d’échanges de langues PineUne introduction aux paramètres

• 3、runtime.debug 、runtime.log、runtime.errorFonction d’extension de FMZ, utilisée pour le débogage。

3 fonctions ont été ajoutées sur la plateforme FMZ pour le débogage.

• runtime.debug: Cette fonction n’est généralement pas utilisée pour imprimer des informations sur les variables dans la console.

• runtime.log: le contenu de la sortie du journal │ FMZ PINE a une fonction spécifique │

  runtime.log(1, 2, 3, close, high, ...)，可以传多个参数。
  

• runtime.error: provoque une erreur d’exécution avec le message d’erreur indiqué dans le paramètre message.

  runtime.error(message)
  

• 4/ Une partie de la fonction de dessin est étendueoverlayparamètre

Fonction de dessin de la langue Pine sur FMZplot、plotshape、plotcharIl y en a plus.overlayPrise en charge des paramètres, permettant de spécifier des images dans le graphique principal ou le sous-graphique.overlayinstallationtrueLe tableau de bord a été modifié.falsePeindre dans les sous-diagrammes permet de dessiner simultanément le tableau principal et le sous-diagramme lorsque la stratégie Pine sur FMZ fonctionne.

• 5、syminfo.mintickPrise de valeur de la variable intégrée

syminfo.mintickLes variables intégrées sont définies comme les valeurs de mesure minimales de la variété actuelle.Offre ferme/BacktestingLa valeur est contrôlée par le paramètre de modèle Pricing Currency Precision dans la bibliothèque de classes de négociation du langage Pine dans l’interface. Le paramètre de Pricing Currency Precision est réglé sur 2, c’est-à-dire que le prix est précis au second degré de la somme des nombres minimes, lorsque le prix est le plus petit mouvement de 0,01syminfo.mintickLa valeur de l’équation est 0.01 .

• 6/ Le prix moyen de FMZ PINE Script est celui qui inclut les frais de traitement

Par exemple: le prix de commande est de 8000, la direction de vente, la quantité de 1 main ((un, une feuille), le prix moyen après la transaction n’est pas de 8000, moins de 8000 ((le coût comprend les frais de traitement)).

Base de la langue Pine

Lorsque nous commençons à apprendre les bases du langage Pine, il est possible que nous ne soyons pas familiers avec les instructions et la grammaire du code dans certains exemples. Peu importe que nous ne comprenions pas. Nous pouvons d’abord nous familiariser avec les concepts, comprendre le but du test, ou consulter la documentation du langage Pine de FMZ pour voir les instructions.

Exécution du modèle

Les stratégies de langage de Pine sont basées sur des graphiques et peuvent être comprises comme une série de calculs et d’opérations, exécutées dans un graphique par ordre chronologique, à partir des données les plus anciennes déjà chargées. La quantité de données initialement chargées sur le graphique est limitée.bar_indexRéférences à l’index de la barre de ligne K actuelle lors de l’exécution du script Pine.

plot(bar_index, "bar_index")

plotLa fonction est l’une des fonctions que nous utiliserons le plus à l’avenir.bar_indexLa ligne est nomméebar_indexOn peut voir que la ligne nommée bar_index sur la première barre a une valeur de 0 et augmente de 1 avec l’augmentation de la barre vers la droite.

Les modèles d’exécution des stratégies varient selon les paramètres de la stratégie.收盘价模型et实时价模型Le concept de modèle de prix de clôture et de modèle de prix en temps réel a été présenté brièvement précédemment.

• Modèle de prix de clôture

Lorsque le code de stratégie est exécuté, le cycle de la barre K actuelle est terminé, et lorsque la barre K est fermée, le cycle de la barre K est terminé. À ce moment-là, la logique de la stratégie Pine est exécutée à nouveau, et le signal de transaction déclenché sera exécuté au début de la barre K suivante.

• Modèle de prix en temps réel

Lors de l’exécution du code de stratégie, la barre de ligne K actuelle, qu’elle soit fermée ou non, exécute une fois la logique de la stratégie Pine à chaque changement de situation, et le signal de transaction déclenché est immédiatement exécuté.

Lorsque la stratégie du langage Pine est exécutée de gauche à droite sur le graphique, la ligne K de la barre est divisée en历史Baret实时BarPour:

• Le Bar de l’Histoire

Lorsque la stratégie est définie comme un “modèle de prix réel” et commence à s’exécuter, toutes les barres K du graphique, à l’exception de la barre K située à droite,历史BarLa logique stratégique dans chaque racine历史BarIl suffit de le faire une fois. Lorsque la stratégie est définie comme un “modèle de prix de clôture” et qu’elle commence à s’exécuter, toutes les barres du graphique sont历史BarLa logique stratégique dans chaque racine历史BarIl suffit de le faire une fois.

Calcul basé sur la barre historique: Le code de stratégie s’exécute une fois dans la barre d’historique en cours de fermeture, puis il continue à s’exécuter dans la barre d’historique suivante jusqu’à ce que toutes les barres d’historique aient été exécutées une fois.

• Bar en temps réel

Lorsque la stratégie est exécutée sur la dernière barre de ligne K à l’extrême droite, la barre devient une barre en temps réel. Lorsque la barre en temps réel est fermée, la barre devient une barre en temps réel passée (c’est-à-dire une barre d’historique). La barre en temps réel nouvelle est générée à l’extrême droite du graphique.

Lorsque la stratégie est définie comme un “modèle de prix en temps réel” et commence à s’exécuter, une logique de stratégie est exécutée à chaque changement de situation dans la barre en temps réel. La stratégie définie comme “modèle de prix de clôture” n’affiche pas la barre en temps réel au début de l’exécution.

Selon les calculs de Bar en temps réel: Si la stratégie est définie comme un graphique de “modèle de prix de clôture” et que la Bar n’est pas affichée en temps réel, le code de la stratégie n’est exécuté qu’une seule fois à la clôture de la Bar en cours. Si la stratégie est définie comme un “modèle de prix de placement réel”, le calcul sur la barre en temps réel est complètement différent de celui sur la barre d’historique. Chaque changement de situation sur la barre en temps réel exécute un code de stratégie. Par exemple, les variables intégréeshigh、low、closeDans la barre d’historique, ces valeurs sont déterminées, dans la barre en temps réel, ces valeurs peuvent changer à chaque fois que la situation change. Ainsi, les indicateurs tels que les données calculées sur la base de ces valeurs peuvent également changer en temps réel. Dans la barre en temps réelcloseLes prix sont toujours les plus récents.highetlowToujours représente le plus haut et le plus bas depuis le début de la barre en temps réel. Ces variables intégrées représentent la valeur finale lors de la dernière mise à jour de la barre en temps réel.

Le mécanisme de retour en arrière lors de l’exécution de la stratégie sur la barre en temps réel (modèle de prix en temps réel): Lors de l’exécution de Bar en temps réel, chaque nouvelle génération de la stratégie exécute une variable définie par l’utilisateur précédemment réinitialisée, appelée un retour en arrière. Pour comprendre le mécanisme de retour en arrière, prenons l’exemple du code de test suivant.

Avis:

  /*backtest 
  ...
  ..
  .
  */

Le paquet contient des informations de configuration de retour enregistrées sous forme de code sur la plate-forme FMZ.

  /*backtest
  start: 2022-06-03 09:00:00
  end: 2022-06-08 15:00:00
  period: 1m
  basePeriod: 1m
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */

  var n = 0
  if not barstate.ishistory
      runtime.log("n + 1之前, n:", n, " 当前bar_index:", bar_index)
      n := n + 1
      runtime.log("n + 1之后, n:", n, " 当前bar_index:", bar_index)

  plot(n, title="n")

Nous n’avons examiné que les scènes exécutées en temps réel dans le Bar, donc nous avons utilisénot barstate.ishistoryRestriction d’expression: n variables sont ajoutées uniquement en temps réel à Bar et utilisées avant et après l’exécution d’une opération d’agrégationruntime.logLes informations de sortie de la fonction sont dans le journal de stratégie.plotLa courbe tracée n peut être vue comme n ayant toujours été 0 lorsque la stratégie était en cours d’exécution dans la barre d’historique. Lorsque l’opération a été exécutée dans la barre en temps réel, elle a déclenché n actions cumulées de 1 et n actions cumulées de 1 ont été exécutées à chaque tour d’exécution de la stratégie sur la barre en temps réel. On peut observer à partir des informations du journal que chaque tour de réexécution du code de la stratégie n est réinitialisé à la valeur de la dernière commande de la stratégie d’exécution de la barre en temps réel.

Pour résumer: 1 Lorsque la stratégie commence à s’exécuter dans la barre en temps réel, un code de stratégie est exécuté à chaque mise à jour de la situation. 2. Lors de l’exécution sur la barre en temps réel, les variables sont renvoyées avant chaque exécution du code de stratégie. 3/ Lors de l’exécution sur la barre en temps réel, les variables sont soumises une fois lors de la mise à jour de la clôture.

Les opérations de dessin comme les courbes sur le graphique peuvent également entraîner un redessin, car les données sont récurrentes, par exemple, nous avons modifié le code de test que nous venons de tester, test sur disque dur:

  var n = 0
  if not barstate.ishistory
      runtime.log("n + 1之前, n:", n, " 当前bar_index:", bar_index)
      n := open > close ? n + 1 : n
      runtime.log("n + 1之后, n:", n, " 当前bar_index:", bar_index)

  plot(n, title="n")

Capture d’écran du moment A

Capture d’écran du moment B

Nous avons seulement modifié la phrase suivante:n := open > close ? n + 1 : nComme on peut le voir sur le premier graphique (moment A), le prix d’ouverture étant supérieur au prix de clôture (moment B), le prix d’ouverture est inférieur au prix de clôture (moment A), le prix n est renouvelé et n n est pas renouvelé. La courbe de la courbe n est immédiatement redessinée, alors que le n sur la courbe est de 4.

• Contexte de la variable dans la fonction

Examinons ensemble les variables dans les fonctions du langage de Pine. Selon les descriptions de certains didacticiels de Pine, les variables dans les fonctions diffèrent des variables extérieures aux fonctions de la façon suivante:

L’historique des variables de la série utilisée dans une fonction Pine est créé par chaque appel consécutif de la fonction. Si la fonction n’est pas appelée dans chaque colonne de l’exécution du script, cela entraînera une différence entre les valeurs d’historique des séries internes et externes de la fonction. Par conséquent, si la fonction n’est pas appelée dans chaque colonne, les séries qui utilisent la même valeur d’indexation et qui sont référencées à l’intérieur et à l’extérieur de la fonction ne référenceront pas les mêmes points d’historique.

Il n’y a pas de problème, nous l’avons compris avec un code de test exécuté sur FMZ:

  /*backtest
  start: 2022-06-03 09:00:00
  end: 2022-06-08 15:00:00
  period: 1m
  basePeriod: 1m
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */

  f(a) => a[1]
  f2() => close[1]  

  oneBarInTwo = bar_index % 2 == 0
  plotchar(oneBarInTwo ? f(close) : na, title = "f(close)", color = color.red, location = location.absolute, style = shape.xcross, overlay = true, char = "A")   
  plotchar(oneBarInTwo ? f2() : na, title = "f2()", color = color.green, location = location.absolute, style = shape.circle, overlay = true, char = "B")   
  plot(close[2], title = "close[2]", color = color.red, overlay = true)
  plot(close[1], title = "close[1]", color = color.green, overlay = true)

Capture d’écran de la réception en cours

Le code de test est relativement simple et consiste essentiellement à examiner les données citées de deux manières:f(a) => a[1]etf2() => close[1]。

• f(a) => a[1]: utilisation de paramètres de sortie, fonction retournée en derniera[1]。

• f2() => close[1]Utilisation directe de variables intégréesclose, retourne la fonction en dernierclose[1]。

[]Symbole utilisé pour les opérations de référence des valeurs historiques des variables de la série de données, close[1] c’est-à-dire en citant le prix de clôture de la barre précédant le prix de clôture actuel. Notre code de test présente 4 types de données sur le graphique:

• plotchar(oneBarInTwo ? f(close) : na, title = "f(close)", color = color.red, location = location.absolute, style = shape.xcross, overlay = true, char = "A") Dessinez un caractère A, de couleur rouge, quand oneBarInTwo est vraie, puis dessinez la position sur l’axe Y comme suit:f(close)Retourne une valeur

• plotchar(oneBarInTwo ? f2() : na, title = "f2()", color = color.green, location = location.absolute, style = shape.circle, overlay = true, char = "B") Dessinez un caractère sur B, de couleur verte, et dessinez-le lorsque oneBarInTwo est vraie, la position dessinée (sur l’axe Y) estf2()Retourne une valeur

• plot(close[2], title = "close[2]", color = color.red, overlay = true) La ligne, colorée en rouge, est dessinée comme suit (sur l’axe Y):close[2]C’est-à-dire le prix de clôture sur la barre actuelle (à la 2ème ligne de la barre précédente, à la 2ème ligne de la gauche).

• plot(close[1], title = "close[1]", color = color.green, overlay = true) La couleur de la ligne est le vert et la position (sur l’axe Y) est:close[1]C’est-à-dire le prix de clôture sur la barre de la première ligne (à gauche) de la barre actuelle.

Les fonctionnalités utilisées pour marquer le dessin A sont visibles à travers la capture d’écran de fonctionnement de la rétroaction de la stratégief(a) => a[1]et les fonctions utilisées pour marquer Bf2() => close[1]Ils sont utilisés.[1] pour faire référence aux données historiques de la série de données, mais la position des marqueurs “A” et “B” sur le graphique est complètement différente. La position du marqueur “A” est toujours sur la ligne rouge, c’est-à-dire le code de la stratégieplot(close[2], title = "close[2]", color = color.red, overlay = true)La ligne est dessinée et les données utilisées sont:close[2]。

La raison en est l’indexation par la barre de ligne K, qui est une variable intégrée.bar_indexCalculer si les marqueurs “A” et “B” doivent être dessinés. Les marqueurs “A” et “B” ne doivent pas être dessinés sur chaque barre de ligne K.f(a) => a[1]Si la fonction n’est pas appelée sur chaque barre, les valeurs citées de cette façon sont liées à la fonctionf2() => close[1]La valeur de référence de cette façon est différente (même si les deux utilisent[1] avec le même index).

• Certaines fonctions intégrées doivent être calculées sur chaque barre pour pouvoir calculer correctement leur résultat.

Pour illustrer cela, prenons un exemple simple:

  res = close > close[1] ? ta.barssince(close < close[1]) : -1
  plot(res, style = plot.style_histogram, color=res >= 0 ? color.red : color.blue)

Nous allons appeler la fonction en code.ta.barssince(close < close[1])écrite dans un opérateur triangulairecondition ? value1 : value2Cela a entraîné la mort de plus de la moitié de la population.close > close[1]On appelle la fonction ta.barssince.ta.barssinceLa fonction est calculée à partir du dernierclose < close[1]Le nombre de lignes K au moment de la création. Lorsque la fonction ta.barssince est appelée, elle est close > close[1], c’est-à-dire que le prix de clôture actuel est supérieur au prix de clôture de la barre précédente, lorsque la fonction ta.barssince est appelée.[Il n’y a pas de siège, donc pas de siège le plus récent

ta.barssince: Lorsqu’elle est appelée, la fonction renvoie na。 si cette condition n’a jamais été remplie avant la ligne K actuelle.

Comme le montre la figure :

Donc, quand on dessine le diagramme, on ne dessine que les données où la variable res a une valeur ((-1) }}.

Pour éviter ce problème, nous n’utilisons queta.barssince(close < close[1])L’appel de la fonction est tiré de l’opérateur triangulaire et écrit en dehors de n’importe quelle branche conditionnelle possible. Il permet d’effectuer des calculs sur chaque ligne K Bar.

  a = ta.barssince(close < close[1])
  res = close > close[1] ? a : -1
  plot(res, style = plot.style_histogram, color=res >= 0 ? color.red : color.blue)

Séquence chronologique

Le concept de séquence temporelle est très important dans le langage Pine, c’est un concept que nous devons comprendre lorsque nous apprenons le langage Pine. La séquence temporelle n’est pas un type, mais une structure de base pour stocker une succession de valeurs de variables au fil du temps, nous savons que le script Pine est basé sur des graphiques, dont le contenu le plus basique est le diagramme de ligne K. La séquence temporelle dont chaque valeur est associée à une barre de temps de ligne K.openest une variable intégrée du langage Pine (built-in) dont la structure est la séquence de temps de stockage du prix d’ouverture de chaque ligne K de Bar. Elle peut être interprétée commeopenCette structure de séquence de temps représente le prix d’ouverture de toutes les barres de ligne K de la ligne K actuelle depuis la première barre du début jusqu’à la barre de l’exécution du script actuel. Si la ligne K actuelle est une période de 5 minutes, nous utilisons le code de la stratégie Pine pour faire référence à ((ou)openIl s’agit du prix d’ouverture de la ligne K Bar à l’exécution actuelle du code de la stratégie.[]Opérateur: Lorsque la stratégie Pine est exécutée sur une barre de ligne K, utilisezopen[1]Affichage de référenceopenLe prix d’ouverture de la première barre de ligne K exécutée par le script en cours dans la séquence de temps (c’est-à-dire le prix d’ouverture de la dernière période de ligne K).

• Les variables de la séquence temporelle sont très faciles à calculer. Nous avons construit une fonction.ta.cumPar exemple:

  ta.cum

  Cumulative (total) sum of `source`. In other words it's a sum of all elements of `source`.
  ta.cum(source) → series float
  RETURNS
  Total sum series.
  ARGUMENTS
  source (series int/float)
  SEE ALSO
  math.sum

Code de test :

  v1 = 1
  v2 = ta.cum(v1)
  plot(v1, title="v1")
  plot(v2, title="v2")
  plot(bar_index+1, title="bar_index")

Il y a beaucoup de similitudes.ta.cumUne telle fonction intégrée peut traiter directement les données de la séquence temporelle, par exempleta.cumLe premier est d’accumuler les valeurs correspondantes des variables importées sur chaque barre de K, et ensuite nous utilisons un graphique pour faciliter la compréhension.

Le processus d’exécution de la stratégie est basé sur la variable bar_index | - | - | - | - | La stratégie fonctionne sur la première ligne de K, Bar ≠ 0 ≠ 1 ≠ 1. La stratégie fonctionne sur la deuxième ligne de K, Bar, où 1 est le nombre 1 et où 2 est le nombre 2. La stratégie fonctionne sur la troisième racine de K, Bar ≠ 2 ≠ 1 ≠ 3. |…|…|…|…| La stratégie est exécutée sur la première ligne K de N+1

On peut voir que v1, v2 et même bar_index sont en fait des structures de séquences temporelles et que chaque barre contient des données correspondantes. Ce code de test ne diffère pas entre le “modèle de prix en temps réel” et le “modèle de prix de clôture” que si le Bar est affiché sur le graphique. Pour mesurer la vitesse, nous utilisons le test de retour du “modèle de prix de clôture”.

Parce que la variable v1 est 1 sur chaque barre.ta.cum(v1)Comme la fonction est exécutée sur la première ligne Bar de K, et qu’il n’y a que la première ligne Bar, le résultat est 1, et la valeur est donnée à la variable v2。 Quandta.cum(v1)Lorsqu’il est exécuté sur la deuxième ligne K Bar, il y a déjà 2 lignes K Bar ((la première correspondant à la variable bar_index est 0, la deuxième correspondant à la variable bar_index est 1), donc le résultat est 2, attribué à la variable v2, et ainsi de suite. On peut en fait observer que v2 est le nombre de lignes K Bar dans le graphique, puisque l’index des lignes Kbar_indexC’est une augmentation de 0, alorsbar_index + 1En fait, c’est le nombre de lignes de K. On peut voir les lignes dans le diagramme d’observation.v2etbar_indexC’est vrai que c’est une répétition.

Je peux aussi utiliserta.cumLa fonction interne calcule la somme des prix de clôture de toutes les bars sur le graphique actuel, et peut être simplement écrite ainsi:ta.cum(close), lorsque la stratégie est exécutée sur la barre de temps réel sur la droiteta.cum(close)Le résultat obtenu est la somme des prix de clôture de toutes les barres sur le graphique (sans fonctionner à droite, il suffit d’ajouter à la barre actuelle).

Les variables de la séquence temporelle peuvent également être calculées à l’aide d’opérateurs, par exemple:ta.sma(high - low, 14)et les variables intégrées.high(le prix le plus élevé de la barre K) moinslow(K-Line Bar au prix le plus bas)ta.smaLa fonction demande la moyenne.

• Les résultats des appels de fonctions laissent également une trace de valeur dans la séquence temporelle

  v1 = ta.highest(high, 10)[1]
  v2 = ta.highest(high[1], 10)
  plot(v1, title="v1", overlay=true)
  plot(v2, title="v2", overlay=true)

Le code de test est observé en cours de fonctionnement lors de la rétro-analyse.v1etv2Les valeurs sont les mêmes, et les lignes dessinées sur le graphique se chevauchent parfaitement. Les résultats des calculs de l’appel de la fonction laissent des traces de valeurs dans la séquence de temps, par exemple le codeta.highest(high, 10)[1]Parmi eux,ta.highest(high, 10)Les résultats de l’appel de fonction peuvent également être utilisés[1] pour citer sa valeur historique.ta.highest(high, 10)Le résultat estta.highest(high[1], 10)Alors ?ta.highest(high[1], 10)etta.highest(high, 10)[1]C’est tout à fait équivalent.

La validation de l’information de sortie est effectuée par une autre fonction de diagramme:

  a = ta.highest(close, 10)[1]
  b = ta.highest(close[1], 10)
  plotchar(true, title="a", char=str.tostring(a), location=location.abovebar, color=color.red, overlay=true)
  plotchar(true, title="b", char=str.tostring(b), location=location.belowbar, color=color.green, overlay=true)

On peut voir les valeurs des variables a et b dans la séquence temporelle affichées au-dessus et au-dessous de la barre correspondante. Le code du dessin peut être conservé pendant l’apprentissage, car il peut être nécessaire d’envoyer souvent des informations sur le graphique pour les observer lors de tests et d’expériences.

Structure du scénario

Structure générale

Dans la première partie du tutoriel, nous avons résumé les différences entre l’utilisation du langage Pine sur FMZ et sur Trading View. Le code Pine sur FMZ peut être écrit sans numéro de version.indicator()、strategy()Et, pour le moment, pas de soutienlibrary()Bien sûr, pour être compatible avec les versions antérieures du script Pine, la stratégie a été écrite comme suit://@version=5，indicator()，strategy()Il est possible de modifier les paramètres de certaines stratégies.strategy()Les paramètres de transfert dans une fonction.

<version>
<declaration_statement>
<code>

<version>Les informations de contrôle de version peuvent être supprimées.

Notes de rédaction

Langue utilisée par les Pine//En tant que commentaire à une ligne, le langage Pine n’ayant pas de commentaire à plusieurs lignes./**/Utilisé pour les notes en plusieurs lignes.

Le code

Les lignes qui ne sont pas des commentaires ou des instructions du compilateur dans un script sont des déclarations, elles implémentent l’algorithme du script. Une déclaration peut être l’un de ces éléments.

• Déclaration de la variable
• Réattribution de la variable
• Déclaration de fonction
• Appels de fonctions intégrés, appels de fonctions définis par l’utilisateur
• if，for，whileouswitchStructure de l’équation

Les phrases peuvent être classées de plusieurs façons.

• Certaines expressions peuvent être exprimées en une seule ligne, comme la plupart des déclarations de variables, qui ne contiennent qu’une seule ligne d’appel de fonction ou une seule ligne de déclaration de fonction. D’autres, comme les structures, ont toujours besoin de plusieurs lignes, car elles nécessitent un bloc local.
• Les déclarations globales d’un script (c’est-à-dire les parties qui ne font pas partie d’un bloc local) ne peuvent pas être considérées comme空格ou制表符Les lignes qui commencent à la première position de la ligne font, par définition, partie de la portée globale du script.
• Les déclarations de structures ou de fonctions à plusieurs lignes nécessitent toujours unlocal block。 Un bloc local doit se réduire à un sigle ou à quatre espaces (sinon, il sera décodé comme une suite de la ligne de code précédente, c’est-à-dire jugé comme une continuité de la ligne de code précédente), chaque bloc local définissant un autre domaine local。
• Plusieurs phrases à une seule ligne peuvent être enchaînées dans une seule ligne en utilisant la virgule ((,) comme séparateur.
• Une ligne peut contenir des commentaires ou seulement des commentaires.
• Les lignes peuvent également être enroulées (continuer sur plusieurs lignes).

Par exemple, comprenant trois blocs locaux, un dans la déclaration de fonction personnalisée et deux dans la déclaration de variable utilisant la structure if, le code suivant:

indicator("", "", true)             // 声明语句(全局范围)，可以省略不写

barIsUp() =>                        // 函数声明(全局范围)
    close > open                    // 本地块(本地范围)

plotColor = if barIsUp()            // 变量声明 (全局范围)
    color.green                     // 本地块 (本地范围)
else
    color.red                       // 本地块 (本地范围)

runtime.log("color", color = plotColor)  // 调用一个内置函数输出日志 (全局范围)

Modifier le code

Les lignes longues peuvent être divisées en plusieurs lignes, ou “ enroulées ” vers le haut. Les lignes enroulées doivent être réduites dans n’importe quel nombre d’espaces, à condition qu’elles ne soient pas des multiples de 4 (ces limites sont utilisées pour réduire les blocs locaux).

a = open + high + low + close

Le nombre d’espaces à réduire par ligne n’est pas un multiple de 4):

a = open +
      high +
          low +
             close

Un appel à un long plot ((() peut être condensé en:

close1 = request.security(syminfo.tickerid, "D", close)      // syminfo.tickerid 当前交易对的日线级别收盘价数据系列
close2 = request.security(syminfo.tickerid, "240", close)    // syminfo.tickerid 当前交易对的240分钟级别收盘价数据系列
plot(ta.correlation(close, open, 100),                       // 一行长的plot()调用可以被包装
   color = color.new(color.purple, 40),
   style = plot.style_area,
   trackprice = true)

Cependant, comme le bloc local doit grammaticalement commencer par une incrustation (((4 espaces ou 1 sigle), lorsque vous le divisez sur la ligne suivante, la partie continue de l’instruction doit commencer par plus d’une incrustation (((qui n’est pas égal au multiple de 4 espaces). Par exemple:

test(c, o) =>
    ret = c > o ?
       (c > o+5000 ? 
          1 :
              0):
       (c < o-5000 ? 
          -1 : 
              0)
           
                   
a = test(close, open)
plot(a, title="a")

Identificateur et opérateur

Identifiant

Avant d’entendre parler de variables, il faut d’abord comprendre le concept d’identifiant de chaîne.fonctionetLes variablesLe nom d’une variable (ou d’une fonction)fonctionComme nous le verrons plus loin dans ce tutoriel, nous allons d’abord apprendre le symbole de l’oignon, 。

• 1 - Les identifiants doivent être en majuscules(A-Z)ou en minuscule(a-z)Alphabets ou soulignés(_)Début, le premier caractère de l’identifiant ▽
• 2, le caractère suivant le premier caractère de l’identifiant peut êtreLes lettres、Sous-ligneouNuméros。
• 3 Les noms des identifiants sont en majuscules pour les distinguer.

Par exemple, les noms suivants:

fmzVar
_fmzVar
fmz666Var
funcName
MAX_LEN
max_len
maxLen
3barsDown  // 错误的命名！使用了数字字符作为标识符的开头字符

Comme la plupart des langages de programmation, le langage Pine propose des suggestions d’écriture.

• 1, les lettres entières en majuscules sont utilisées pour nommer les constantes.
• 2. UtilisationRègles du Mont des CaméliasNom utilisé pour d’autres identifiants.

// 命名变量、常量
GREEN_COLOR = #4CAF50
MAX_LOOKBACK = 100
int fastLength = 7

// 命名函数
zeroOne(boolValue) => boolValue ? 1 : 0

Outil de calcul

Les opérateurs sont des symboles d’opérateur utilisés dans les langages de programmation pour construire des expressions, et les expressions sont des règles de calcul conçues pour un certain type de calcul lorsque nous écrivons des stratégies. Les opérateurs du langage Pine sont classés selon leur fonctionnalité en:

Les opérateurs d’attribution, d’arithmétique, de comparaison, de logique,? :Les opérateurs triangulaires,[]Opérateur de référence historique:

avec un opérateur arithmétique*Par exemple, le code de test suivant est utilisé pour distinguer les types de problèmes résultant des résultats retournés par l’opérateur de langage Pine dans Trading View:

//@version=5
indicator("")
lenInput = input.int(14, "Length")
factor = year > 2020 ? 3 : 1
adjustedLength = lenInput * factor
ma = ta.ema(close, adjustedLength)  // Compilation error!
plot(ma)

La compilation d’erreurs lors de l’exécution de ce script dans Trading View est due au fait queadjustedLength = lenInput * factorOn obtientseries intCependant,ta.emaLe second paramètre de la fonction ne supporte pas ce type. Cependant, il n’y a pas de restrictions strictes de ce type sur FMZ, et le code ci-dessus fonctionne normalement.

Voici quelques exemples de l’utilisation des différents opérateurs:

---

Opérateur d’attribution

Il existe deux types d’opérateurs d’attribution:=、:=C’est ce que nous avons vu dans quelques exemples au début du tutoriel.

=Opérateur utilisé pour l’initialisation ou la déclaration d’une variable.=Les variables après initialization, déclaration et attribution commencent par cette valeur sur chaque barre suivante. Ce sont des déclarations de variables valides:

a = close           // 使用内置变量赋值给a
b = 10000           // 使用数值赋值
c = "test"          // 使用字符串赋值
d = color.green     // 使用颜色值赋值
plot(a, title="a")
plot(b, title="b")
plotchar(true, title="c", char=str.tostring(c), color=d, overlay=true)

Avisa = closeUne déclaration d’attribution, où la variable a de chaque barre est le prix de clôture actuel de cette barre (closer). Les autres variablesb、c、dLa résistance à la corrosion est inchangée et peut être testée dans un système de rétroaction sur la FMZ. Le résultat peut être vu sur un diagramme.

:=Il est utilisé pour réattribuer des valeurs à des variables existantes.:=L’opérateur est utilisé pour modifier la valeur d’une variable déjà déclarée et initialisée. Si vous utilisez:=L’opérateur attribue une valeur à une variable qui n’a pas été initialiée ou déclarée, ce qui entraîne des erreurs, par exemple:

a := 0

Alors,:=Les opérateurs d’attribution sont généralement utilisés pour réattribuer une valeur à une variable existante, par exemple:

a = close > open 
b = 0 
if a
    b := b + 1

plot(b)

Si vous jugezclose > open(c’est-à-dire que le BAR actuel est le rayonnement solaire), la variable a est la valeur réelle ((true)) ≠, alors le code dans le bloc local de la déclaration if est exécuté.b := b + 1, avec l’opérateur d’attribution:=On redéfinit b en ajoutant un 1 ◦ puis on utilise la fonction plot pour tracer les valeurs de la variable b sur chaque BAR de la séquence temporelle, en les reliant en ligne ◦

Est-ce que nous pensons qu’en créant un rayon de soleil BAR, b continuera à accumuler 1 ? Bien sûr que non, nous n’avons pas utilisé de mot-clé pour la déclaration de la variable b, initialité 0.b=0On peut donc voir que le résultat de ce code est de réinitialiser la variable b à 0 à chaque fois si la variable a est vraie.close > openDonc, pour ce tour de programmation, b est une addition de 1, pour le tracé de la fonction de tracé, b est 1, mais pour le prochain tour de programmation, b est réattribué à 0. C’est là aussi que les débutants du langage Pine peuvent facilement se tromper.

En ce qui concerne les opérateurs d’attribution, il faut développer deux mots-clés:var、varip

• var

En fait, ce mot clé, nous l’avons déjà vu et utilisé dans les tutoriels précédents, mais nous ne l’avons pas exploré en détail à ce moment-là.

var est un mot-clé utilisé pour l’allocation et l’initialization de variables à la fois. Généralement, la syntaxe d’attribution de variables qui ne contient pas le mot-clé var entraîne la suppression de la valeur de la variable chaque fois que les données sont mises à jour. En revanche, lorsqu’on utilise le mot-clé var pour l’allocation de variables, elles conservent leur état même si les données sont mises à jour.

Nous utilisons toujours cet exemple, mais nous utilisons quand nous donnons une valeur à b.varLes mots clés:

  a = close > open 
  var b = 0 
  if a
      b := b + 1

  plot(b)

varLe mot-clé permet à la variable b de n’exécuter que la première attribution initiale, et de ne plus réinitialiser b à 0 à chaque fois que la logique de stratégie est exécutée, de sorte que la ligne dessinée à partir de l’exécution peut être observée pour obtenir b, soit le nombre de lignes de y qui ont été affichées lors de la mesure du BAR de la ligne K actuelle.

Les variables d’une déclaration var peuvent être écrites non seulement au niveau global, mais aussi dans des blocs de code, comme dans cet exemple:

  strategy(overlay=true)
  var a = close
  var b = 0.0
  var c = 0.0
  var green_bars_count = 0
  if close > open
      var x = close
      b := x
      green_bars_count := green_bars_count + 1
      if green_bars_count >= 10
          var y = close
          c := y
  plot(a, title = "a")
  plot(b, title = "b")
  plot(c, title = "c")

La variable ‘a’ conserve le prix de clôture du premier pilier de la série. La variable ‘b’ maintient le prix de clôture de la première barre de prix de l’aluminium vert de la série. La variable ‘c’ maintient le prix de clôture de la dixième pomme de terre verte de la série.

• varip

varipNous avons vu ce mot-clé pour la première fois, et nous pouvons voir sa description:

varip ((var intrabar persist) est un mot-clé pour les variables d’allocation et d’initialisation ponctuelle. Il est similaire au mot-clé var, mais les variables utilisant la déclaration varip conservent leur valeur entre les mises à jour en ligne K en temps réel.

C’est facile à comprendre avec des exemples.

  strategy(overlay=true)

  // 测试 var varip
  var i = 0
  varip ii = 0  

  // 将策略逻辑每轮改变的i、ii打印在图上
  plotchar(true, title="ii", char=str.tostring(ii), location=location.abovebar, color=color.red)
  plotchar(true, title="i", char=str.tostring(i), location=location.belowbar, color=color.green)  

  // 每轮逻辑执行都给i、ii递增1
  i := i + 1
  ii := ii + 1

Le code de test fonctionne différemment sur les modèles de prix de clôture et de prix en temps réel:

Les prix en temps réel: Rappelez-vous que nous avons expliqué précédemment que la stratégie est exécutée en temps réel, en temps réel, en temps réel, en temps réel.var、varipVariables déclaréesi、iiChaque fois que le code de la stratégie est exécuté, des opérations d’augmentation sont effectuées. On peut donc voir que les chiffres affichés sur la ligne KBAR du résultat de la rétro-mesure augmentent un par un. Lorsque la phase de la ligne K historique se termine, la phase de la ligne K en temps réel commence.i := i + 1etii := ii + 1La différence est que ii est modifié à chaque fois. Bien que i soit modifié à chaque fois, la logique d’exécution de la stratégie du prochain tour reprend la valeur précédente (vous vous souvenez du mécanisme de retour en arrière que nous avons expliqué dans la section précédente “Exécution du modèle” ?), jusqu’à ce que la ligne KBAR actuelle soit terminée pour mettre à jour la valeur de détermination de i (c’est-à-dire que la logique d’exécution de la stratégie du prochain tour ne reprend plus la valeur précédente).

Le modèle de clôture: Puisque le modèle de prix de clôture n’exécute une logique stratégique qu’à chaque K-ligne BAR. Dans le modèle de prix de clôture, les phases historiques de la ligne K et les phases de la ligne K en temps réel, les variables de la déclaration var, varip se comportent de manière progressive dans l’exemple ci-dessus, avec une augmentation de 1 pour chaque K-ligne BAR.

---

Opérateur arithmétique

Outil de calcul	illustrer
+	Le plus grand
-	Réduction
*	La multiplication
/	Décision de justice
%	Des modèles

+、-Les opérateurs peuvent être utilisés en tant qu’opérateurs binaires ou en tant qu’opérateurs unitaires. Les autres opérateurs d’arithmétique ne peuvent être utilisés qu’en tant qu’opérateurs binaires.

1 , les opérateurs d’arithmétique sont des types de valeur numérique des deux côtés, ce qui donne un type de valeur numérique, un type entier ou un nombre de points flottants selon le résultat de l’opération. 2. Si le nombre d’opérations est une chaîne, l’opérateur est+, est calculé comme une chaîne de caractères, la valeur est convertie en chaîne de caractères, puis les chaînes sont assemblées. Si c’est un autre opérateur d’arithmétique, on essaie de convertir la chaîne de caractères en valeur et de l’opérer. 3 Si le nombre d’opérations est na, le résultat est nul, et NaN apparaît lors de l’impression sur la FMZ.

a = 1 + 1 
b = 1 + 1.1
c = 1 + "1.1"
d = "1" + "1.1"
e = 1 + na 

runtime.log("a:", a, ", b:", b, ", c:", c, ", d:", d, ", e:", e)   
// a: 2 , b: 2.1 , c: 11.1 , d: 11.1 , e: NaN

Le langage Pine sur FMZ est un peu différent de celui de Trading View, le langage Pine sur FMZ n’est pas très exigeant pour les types de variables. Par exemple:

a = 1 * "1.1"
b = "1" / "1.1"
c = 5 % "A" 

plot(a)
plot(b)
plot(c)

Si le système ne parvient pas à calculer une chaîne de caractères non numérique, le résultat du système est une valeur nulle.

---

Comparer les opérateurs

Les opérateurs de comparaison sont tous des opérateurs binaires.

Outil de calcul	illustrer
<	inférieure à
>	Plus que
<=	inférieur à égal à
>=	Plus est égal à
==	équivalent
!=	Les inégalités

Exemple de test :

a = 1 > 2 
b = 1 < 2 
c = "1" <= 2 
d = "1" >= 2 
e = 1 == 1 
f = 2 != 1 
g = open > close 
h = na > 1 
i = 1 > na

runtime.log("a:", a, ", b:", b, ", c:", c, ", d:", d, ", e:", e, ", f:", f, ", g:", g, ", h:", h, ", i:", i)   
// a: false , b: true , c: true , d: false , e: true , f: true , g: false , h: false , i: false

Comme vous pouvez le voir, l’opérateur de comparaison est très simple à utiliser, mais c’est aussi l’opérateur que nous utilisons le plus souvent pour écrire des stratégies. Vous pouvez comparer des valeurs et des variables intégrées, par exempleclose、openattendez. Comme pour les opérateurs de calcul, la FMZ est différente de la Pin de Trading View, la FMZ n’a pas de type d’exigence particulièrement rigide, de sorte que de telles déclarationsd = "1" >= 2Il n’y a pas de message d’erreur sur FMZ, la chaîne de caractères est d’abord convertie en valeur numérique avant d’être comparée. Il y a un message d’erreur sur Trading View.

---

Opérateur logique

Outil de calcul	Nom du code	illustrer
Pas tout à fait.	not	Unité d’opérateur, non opérationnelle
et	and	Opérateur binaire, avec (et)
ou	or	Opérateur binaire, ou opération

Parler d’opérateur logique, c’est parler de table des valeurs réelles. Comme nous l’avons appris au lycée, mais ici nous testons et apprenons dans le système de rétroaction:

a = 1 == 1  // 使用比较运算符构成的表达式，结果为布尔值
b = 1 != 1
c = not b   // 逻辑非操作符
d = not a   // 逻辑非操作符

runtime.log("测试逻辑操作符：and", "#FF0000")
runtime.log("a:", a, ", c:", c, ", a and c:", a and c)
runtime.log("a:", a, ", b:", b, ", a and b:", a and b)
runtime.log("b:", b, ", c:", c, ", b and c:", b and c)
runtime.log("d:", d, ", b:", b, ", d and b:", d and b)

runtime.log("测试逻辑操作符：or", "#FF0000")
runtime.log("a:", a, ", c:", c, ", a or c:", a or c)
runtime.log("a:", a, ", b:", b, ", a or b:", a or b)
runtime.log("b:", b, ", c:", c, ", b or c:", b or c)
runtime.log("d:", d, ", b:", b, ", d or b:", d or b)

runtime.error("stop")

Pour éviter que le système de suivi ne soit affecté par l’impression continue d’informations, nous utilisonsruntime.error("stop")L’expression est utilisée pour exécuter une impression, puis lancer une erreur anormale qui arrête le test de retour. On peut alors observer l’information en sortie et constater que le contenu de l’impression et la table de valeurs réelles sont en fait les mêmes.

---

Opérateur de trinité

Utilisation de l’opérateur trinitaire? :Expression triangulaire combinée à un nombre d’opérationscondition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseNous l’avons déjà vu dans les cours précédents. Les expressions dites triangulaires, ou opérateurs triangulaires, signifient qu’il y a trois opérations en tout.

condition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseLes résultats sont les suivants:conditionest la condition de jugement si la valeur de l’expression de la règle de vérité est:valueWhenConditionIsTrueSiconditionLa valeur de l’expression estvalueWhenConditionIsFalse。

Il n’y a pas beaucoup d’utilité pratique, mais des exemples qui peuvent être utiles pour la démonstration:

a = close > open
b = a ? "阳线" : "阴线"
c = not a ? "阴线" : "阳线"
plotchar(a, location=location.abovebar, color=color.red, char=b, overlay=true)
plotchar(not a, location=location.belowbar, color=color.green, char=c, overlay=true)

Si vous rencontrez une croix, ça ne fait rien ! L’expression triangulaire peut aussi être encastrée, comme nous l’avons fait dans le tutoriel précédent.

a = close > open
b = a ? math.abs(close-open) > 30 ? "阳线" : "十字星" : math.abs(close-open) > 30 ? "阴线" : "十字星"
c = not a ? math.abs(close-open) > 30 ? "阴线" : "十字星" : math.abs(close-open) > 30 ? "阳线" : "十字星"
plotchar(a, location=location.abovebar, color=color.red, char=b, overlay=true)
plotchar(not a, location=location.belowbar, color=color.green, char=c, overlay=true)

C’est l’équivalent decondition ? valueWhenConditionIsTrue : valueWhenConditionIsFalseDansvalueWhenConditionIsTrue、valueWhenConditionIsFalse, et utilise une autre expression trinitaire au lieu de ▽.

---

Opérateur historique

Utilisation de l’opérateur historique[]Les valeurs historiques sont les valeurs de la variable sur la ligne K BAR précédant la ligne K BAR actuelle au moment de l’exécution du script.[]Les opérateurs sont utilisés après les appels de variables, d’expressions et de fonctions.[]Le nombre dans les crochets est le décalage de l’historique à laquelle nous faisons référence par rapport à la ligne K BAR actuelle. Par exemple, si je veux faire référence à la clôture d’une ligne K BAR, j’écrirai:close[1]。

Nous avons déjà vu une écriture similaire dans les