# Deepwick Script

Deepwick Script est le langage des graphiques et des backtests de Deepwick. C'est un
**sous-ensemble de Pine Script v5/v6** : la plupart des appels `ta.*`, `math.*`, `str.*`,
`array.*`, `map.*`, `input.*`, `plot*` et `strategy.*` fonctionnent exactement comme dans Pine.
Deepwick n'est pas affiliée à TradingView ; Pine Script est une marque de TradingView, Inc.

Un script s'exécute une fois par bougie, de la plus ancienne à la plus récente, et chaque
variable conserve son historique : la même sémantique de série que dans Pine.

## Les règles qui comptent quand on génère du code

- **Consultez la liste des non pris en charge avant d'écrire.** Un appel non pris en charge est l'erreur la plus coûteuse ici : la plupart compilent et renvoient `na` en silence, donc un script peut sembler correct et ne rien tracer.
- **`request.security()` fonctionne pour une temporalité supérieure du symbole du graphique lui-même.** `request.security(syminfo.tickerid, "240", close)` donne le dernier close *fermé* 4h, et l'expression peut être un appel `ta.*`. Un autre **symbole** renvoie `na` : le moteur ne détient que les bougies du graphique, il n'ira pas en chercher une autre.
- **Pas d'anticipation.** Le courtier du backtest ne remplit jamais un ordre avec des données du futur : les ordres au marché sont remplis à l'*ouverture de la bougie suivante*.
- **Les coûts sont réels.** Chaque exécution paie commission et slippage tels que déclarés dans `strategy()`. Une stratégie rentable à coût zéro peut ne pas l'être avec eux.
- **Les stops et les limites suivent la bougie**, dans l'ordre ouverture, extrême le plus proche, extrême le plus lointain, clôture. Un ordre que le prix a franchi par un gap est rempli à l'ouverture.
- **Déclarez avec `=`, réassignez avec `:=`.** Utilisez `var` pour l'état qui doit persister d'une bougie à l'autre.
- **L'indentation fait quatre espaces.** Pine n'a pas d'accolades ; les blocs de `if`/`for`/`while`/`switch` sont des blocs indentés.
- **Les arguments nommés vont à la fin.** Dès que vous écrivez `nom=`, tous les arguments suivants doivent être nommés aussi : `plotshape(series=x, title="t", style=shape.circle)` est valide, `plotshape(x, "t", style=…)` ne l'est pas. Mélanger un positionnel après un nommé arrête le script sur une erreur de syntaxe.
- **Une sortie ne peut pas se déclencher sur la bougie qui l'a émise.** Un `strategy.entry` au marché est rempli à l'*ouverture de la bougie suivante*, donc un `strategy.exit` écrit sur cette bougie ne peut se remplir qu'à partir de la suivante. Un prix qui serait déjà passé sous votre stop sur la bougie qui l'a émis n'est pas exécuté contre vous.
- **Une sortie à deux branches ne se déclenche qu'une fois.** Quand une branche de `strategy.exit(stop=…, limit=…)` est remplie, l'autre est annulée avec elle : un trade, jamais deux. Si la bougie atteint les deux niveaux, celui qui est atteint d'abord en suivant le parcours de la bougie gagne.
- **Stops suiveurs :** `strategy.exit(trail_points=N, trail_offset=M)`. Les deux sont en **ticks**, pas en unités de prix. `trail_offset` est le profit qui doit être effacé avant que le stop s'arme ; `trail_points` est la distance gardée depuis le meilleur prix atteint. Le stop ne se resserre qu'en votre faveur et bouge sur des bougies closes.

## Référence des fonctions

Les signatures et ce que chacune fait. Les arguments sont dans l'ordre où vous les écrivez.

### Langage

Deepwick Script exécute un sous-ensemble de Pine Script, y compris les enums, les types définis par l'utilisateur, les méthodes et les maps ; la ligne //@version n'est pas vérifiée. Un script s'exécute une fois par bougie, de la plus ancienne à la plus récente, et chaque variable conserve son historique.

- `x = expr / x := expr` — Déclare une variable, puis réassigne-la avec :=. Un type facultatif (int, float, bool, string, color, series, simple, const, line, label) peut précéder le nom.
- `var / varip` — S'initialise une seule fois sur la première bougie et conserve la valeur d'une bougie à l'autre. varip se comporte comme var, puisque les scripts s'exécutent sur des bougies closes.
- `x[n]` — Opérateur d'historique : la valeur de x il y a n bougies (na avant la première bougie).
- `if / else` — Blocs conditionnels, indentés de quatre espaces. if peut aussi s'utiliser comme expression.
- `cond ? a : b` — Opérateur ternaire.
- `switch` — Branchement multiple, avec ou sans valeur à comparer.
- `for i = a to b [by step]` — Boucle comptée. break et continue sont pris en charge.
- `while cond` — Boucle tant qu'une condition reste vraie.
- `f(x, y) => expr` — Fonction définie par l'utilisateur, sur une ligne ou comme un bloc indenté dont la dernière expression est renvoyée. Chaque site d'appel conserve son propre état ta.*, comme dans Pine.
- `[a, b] = f()` — Tuples : les fonctions peuvent renvoyer plusieurs valeurs, et les natives comme ta.macd() et ta.bb() le font.
- `and / or / not` — Opérateurs logiques. Arithmétique : + - * / % ; comparaison : == != < <= > >=.

### Déclarations

- `indicator(title, shorttitle, overlay, precision)` (study) — Déclare un indicateur : il se dessine sur le graphique et n'a rien à tester. study() est accepté comme alias.
- `strategy(title, overlay, initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, slippage, pyramiding)` — Déclare une stratégie. Par défaut : initial_capital 100000, 1 contrat par ordre, commission 0, slippage 0 ticks, pyramiding 1. Les autres arguments, comme process_orders_on_close, sont ignorés.

### Entrées

Les entrées apparaissent à côté de l'éditeur et dans les réglages de l'indicateur, pour les modifier sans toucher au code.

- `input.int(defval, title, minval, maxval, step)` — Nombre entier.
- `input.float(defval, title, minval, maxval, step)` — Nombre décimal.
- `input.bool(defval, title)` — Case à cocher.
- `input.string(defval, title, options)` — Texte, ou une liste d'options.
- `input.session(defval, title)` — Une séance de trading comme "0930-1600", ou des jours comme "23456". Passez-la à session.ismarket() et aux autres prédicats session.*.
- `input.source(defval, title)` — Une source de prix : open, high, low, close, hl2, hlc3, ohlc4 ou hlcc4.
- `input.color(defval, title)` — Sélecteur de couleur.
- `input(defval, title)` — Entrée générique ; le type suit la valeur par défaut.

### Données et heure de la bougie

Les heures sont en millisecondes UTC. hour() et les autres fonctions de temps acceptent une heure facultative ; hour() accepte aussi un fuseau horaire issu d'une liste fixe de décalages, sans heure d'été.

- `open, high, low, close, volume` (open, high, low, close, volume) — Prix et volume de la bougie courante.
- `hl2, hlc3, ohlc4, hlcc4` (hl2, hlc3, ohlc4, hlcc4) — Moyennes de prix usuelles.
- `bar_index, last_bar_index` (bar_index, last_bar_index) — Indice de la bougie courante (0 est la plus ancienne) et de la dernière bougie.
- `time, time_close` (time, time_close) — Heure d'ouverture et de clôture de la bougie. En tant que fonctions — time("D"), time(timeframe.period, "0000-0900:23456", "UTC") — le début (ou la fin) de la bougie de temporalité supérieure qui contient celle-ci, ou na lorsque la bougie est hors séance. Séances : "HHMM-HHMM", aussi nocturnes, plusieurs fenêtres séparées par des virgules, jours facultatifs après deux-points (1 = dimanche … 7 = samedi), "24x7".
- `timeframe.change(timeframe)` — Vrai sur la première bougie de chaque nouvelle période, p. ex. timeframe.change("D") sur la première bougie de chaque jour (les semaines commencent le lundi).
- `timestamp(timezone?, year, month, day, hour, minute, second)` — Une heure en millisecondes à partir de ses composantes, ou d'une date en texte : timestamp("2026-01-05T09:30:00Z").
- `dayofweek.sunday … dayofweek.saturday` (dayofweek.monday, dayofweek.tuesday, dayofweek.wednesday, dayofweek.thursday, dayofweek.friday, dayofweek.saturday) — Constantes de jour à comparer avec dayofweek (1 … 7).
- `session.ismarket, isfirstbar, islastbar, ispremarket, ispostmarket` (session.ismarket, session.isfirstbar, session.islastbar, session.ispremarket, session.ispostmarket) — État de la séance. Ici les marchés traders presque en continu, donc chaque bougie est en séance ; isfirstbar / islastbar marquent la première et la dernière bougie de chaque jour UTC.
- `year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second` (year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second) — Parties du calendrier de l'heure de la bougie ; appelables aussi avec une heure, p. ex. hour(time, "America/New_York"). dayofweek : 1 = dimanche … 7 = samedi.
- `barstate.isfirst, islast, isnew, isconfirmed, ishistory, isrealtime` (barstate.isfirst, barstate.islast, barstate.isnew, barstate.isconfirmed, barstate.ishistory, barstate.isrealtime) — Où se situe le script dans l'historique des bougies.
- `timeframe.period, multiplier, isintraday, isdaily, isweekly, ismonthly` (timeframe.period, timeframe.multiplier, timeframe.isintraday, timeframe.isdaily, timeframe.isweekly, timeframe.ismonthly) — La temporalité du graphique.
- `syminfo.ticker, tickerid, mintick, pointvalue` (syminfo.ticker, syminfo.tickerid, syminfo.mintick, syminfo.pointvalue) — Le symbole du graphique, son pas de prix et sa valeur du point.

### Analyse technique (ta.*)

Chaque site d'appel conserve son propre état, comme dans Pine : deux appels ta.ema() sur des lignes différentes sont deux moyennes indépendantes. Le résultat vaut na tant qu'il n'y a pas assez de bougies.

- `ta.sma(source, length)` — Moyenne mobile simple.
- `ta.ema(source, length)` — Moyenne mobile exponentielle.
- `ta.rma(source, length)` — Moyenne mobile de Wilder, utilisée par le RSI et l'ATR.
- `ta.wma(source, length)` — Moyenne mobile pondérée.
- `ta.vwma(source, length)` — Moyenne mobile pondérée par le volume.
- `ta.hma(source, length)` — Moyenne mobile de Hull.
- `ta.linreg(source, length, offset)` — Valeur de la droite de régression linéaire.
- `ta.vwap(source)` — Prix moyen pondéré par le volume, qui repart à 00:00 UTC chaque jour.
- `ta.rsi(source, length)` — Indice de force relative, de 0 à 100.
- `ta.macd(source, fastlen, slowlen, siglen)` — Renvoie [macd, signal, histogram].
- `ta.stoch(source, high, low, length)` — Stochastique %K, de 0 à 100.
- `ta.cci(source, length)` — Indice de canal des matières.
- `ta.mfi(series, length)` — Indice de flux de monnaie.
- `ta.wpr(length)` — Williams %R, de -100 à 0.
- `ta.dmi(diLength, adxSmoothing)` — Renvoie [+DI, -DI, ADX].
- `ta.supertrend(factor, atrPeriod)` — Renvoie [supertrend, direction] ; la direction vaut -1 dans une tendance haussière et 1 dans une tendance baissière.
- `ta.sar(start, inc, max)` — SAR parabolique.
- `ta.mom(source, length)` — Momentum : la source moins la source d'il y a length bougies.
- `ta.roc(source, length)` — Taux de variation, en pourcentage.
- `ta.change(source, length)` — Écart avec la valeur d'il y a length bougies (1 par défaut).
- `ta.tr / ta.tr(handle_na)` — True range.
- `ta.atr(length)` — Average true range (Wilder).
- `ta.bb(series, length, mult)` — Bandes de Bollinger : renvoie [middle, upper, lower].
- `ta.bbw(series, length, mult)` — Largeur des bandes de Bollinger : (upper - lower) / middle.
- `ta.kc(series, length, mult)` — Canaux de Keltner : renvoie [middle, upper, lower], avec une moyenne exponentielle du true range.
- `ta.stdev(source, length, biased)` — Écart-type.
- `ta.variance(source, length, biased)` — Variance.
- `ta.dev(source, length)` — Écart moyen absolu.
- `ta.median(source, length)` — Médiane.
- `ta.highest(source, length) / ta.highest(length)` — Valeur la plus haute sur length bougies (le high par défaut).
- `ta.lowest(source, length) / ta.lowest(length)` — Valeur la plus basse sur length bougies (le low par défaut).
- `ta.highestbars(source, length)` — Décalage par rapport au plus haut : 0 ou négatif.
- `ta.lowestbars(source, length)` — Décalage par rapport au plus bas : 0 ou négatif.
- `ta.rising(source, length)` — Vrai si la source est au-dessus de chacune de ses length valeurs précédentes.
- `ta.falling(source, length)` — Vrai si la source est en dessous de chacune de ses length valeurs précédentes.
- `ta.crossover(source1, source2)` — Vrai sur la bougie où source1 croise au-dessus de source2.
- `ta.crossunder(source1, source2)` — Vrai sur la bougie où source1 croise en dessous de source2.
- `ta.cross(source1, source2)` — Vrai sur un croisement dans les deux sens.
- `ta.pivothigh(source, leftbars, rightbars)` — Le prix du pivot high, connu rightbars bougies après le pivot ; na sinon. La source est facultative (le high par défaut).
- `ta.pivotlow(source, leftbars, rightbars)` — Le prix du pivot low, connu rightbars bougies après le pivot ; na sinon. La source est facultative (le low par défaut).
- `ta.valuewhen(condition, source, occurrence)` — Valeur de la source sur la occurrence-ième bougie la plus récente où la condition était vraie.
- `ta.barssince(condition)` — Nombre de bougies depuis la dernière fois où la condition était vraie.
- `ta.cum(source)` — Total cumulé depuis la première bougie.

### Stratégies (strategy.*)

Les ordres au marché s'exécutent à l'ouverture de la bougie suivante. Les ordres stop et limit s'exécutent le long de la bougie : ouverture, puis l'extrême le plus proche de l'ouverture, puis l'autre extrême, puis la clôture. Si le prix ouvre un gap à travers un ordre, celui-ci s'exécute à l'ouverture. La commission est prélevée à chaque exécution ; le slippage s'applique aux exécutions au marché et stop.

- `strategy.entry(id, direction, qty, limit, stop, comment)` — Ouvre ou augmente une position ; ordre au marché sauf si limit ou stop est indiqué.
- `strategy.order(id, direction, qty, limit, stop, comment)` — Les mêmes arguments que strategy.entry().
- `strategy.exit(id, from_entry, qty_percent, profit, limit, loss, stop, trail_points, trail_offset, comment)` — Take-profit, stop-loss et stop suiveur d'une entrée : profit et perte en ticks, limit et stop en prix. trail_points est la distance en TICKS depuis le meilleur prix atteint ; trail_offset est le profit en ticks qu'il faut effacer avant que le stop suiveur ne s'arme. Le stop ne se resserre que en votre faveur et bouge sur des bougies CLOSES : une bougie ne peut donc jamais exécuter le stop qu'elle a elle-même fixé.
- `strategy.close(id, comment, qty_percent)` — Ferme une entrée au marché à la bougie suivante.
- `strategy.close_all(comment)` — Ferme toutes les positions ouvertes.
- `strategy.cancel(id) / strategy.cancel_all()` (strategy.cancel_all) — Annule les ordres en attente.
- `strategy.position_size, position_avg_price` (strategy.position_size, strategy.position_avg_price) — Position courante (positive longue, négative courte) et son prix moyen.
- `strategy.opentrades.entry_bar_index(n), entry_price, entry_time, entry_id, size, profit, commission, max_runup, max_drawdown` (strategy.opentrades.entry_price, strategy.opentrades.entry_time, strategy.opentrades.entry_id, strategy.opentrades.size, strategy.opentrades.profit, strategy.opentrades.commission, strategy.opentrades.max_runup, strategy.opentrades.max_drawdown) — Détails de l'opération ouverte n (0 = la plus ancienne) ; na si elle n'existe pas. size est négatif sur les positions vendeuses. Ex. sortir après 10 bougies : bar_index - strategy.opentrades.entry_bar_index(0) >= 10.
- `strategy.closedtrades.entry_bar_index(n), exit_bar_index, entry_price, exit_price, entry_time, exit_time, entry_id, size, profit, commission, max_runup, max_drawdown` (strategy.closedtrades.exit_bar_index, strategy.closedtrades.entry_price, strategy.closedtrades.exit_price, strategy.closedtrades.entry_time, strategy.closedtrades.exit_time, strategy.closedtrades.entry_id, strategy.closedtrades.size, strategy.closedtrades.profit, strategy.closedtrades.commission, strategy.closedtrades.max_runup, strategy.closedtrades.max_drawdown) — Détails de l'opération fermée n (0 = la plus ancienne ; la dernière est strategy.closedtrades - 1).
- `strategy.equity, netprofit, openprofit, grossprofit, grossloss, initial_capital` (strategy.equity, strategy.netprofit, strategy.openprofit, strategy.grossprofit, strategy.grossloss, strategy.initial_capital) — Chiffres du compte.
- `strategy.closedtrades, opentrades, wintrades, losstrades` (strategy.closedtrades, strategy.opentrades, strategy.wintrades, strategy.losstrades) — Nombre d'opérations.
- `strategy.long, strategy.short` (strategy.long, strategy.short) — Directions.
- `strategy.fixed, strategy.cash, strategy.percent_of_equity` (strategy.fixed, strategy.cash, strategy.percent_of_equity) — Valeurs de default_qty_type.
- `strategy.commission.percent, cash_per_order, cash_per_contract` (strategy.commission.percent, strategy.commission.cash_per_order, strategy.commission.cash_per_contract) — Valeurs de commission_type.

### Tracés et alertes

- `plot(series, title, color, linewidth, style)` — Dessine une série sur le graphique ou dans un panneau.
- `plotshape(series, title, style, location, color, text)` — Dessine une forme sur les bougies où series est vraie.
- `plotchar(series, title, char, location, color)` — Dessine un caractère sur les bougies où series est vraie.
- `hline(price, title, color, linestyle)` — Ligne horizontale à un niveau fixe.
- `fill(plot1, plot2, color)` — Remplit entre deux tracés ou deux hlines.
- `bgcolor(color)` — Colore le fond de la bougie.
- `barcolor(color)` — Colore la bougie elle-même.
- `alertcondition(condition, title, message)` — Déclare une condition que vous pouvez transformer en alerte par email, Telegram, Discord ou webhook.
- `plot.style_*` (plot.style_line, plot.style_linebr, plot.style_stepline, plot.style_histogram, plot.style_columns, plot.style_circles, plot.style_cross, plot.style_area) — line, linebr, stepline, histogram, columns, circles, cross, area.
- `hline.style_*` (hline.style_solid, hline.style_dashed, hline.style_dotted) — solid, dashed, dotted.
- `shape.*` (shape.triangleup, shape.triangledown, shape.arrowup, shape.arrowdown, shape.circle, shape.xcross, shape.cross, shape.diamond, shape.square, shape.flag, shape.labelup, shape.labeldown) — triangleup, triangledown, arrowup, arrowdown, circle, xcross, cross, diamond, square, flag, labelup, labeldown.
- `location.*` (location.abovebar, location.belowbar, location.top, location.bottom, location.absolute) — abovebar, belowbar, top, bottom, absolute.
- `size.*` (size.auto, size.tiny, size.small, size.normal, size.large, size.huge) — auto, tiny, small, normal, large, huge. Accepté, mais les formes sont dessinées à une seule taille.

### Lignes et cadres

- `line.new(x1, y1, x2, y2, extend, color, style, width)` — Dessine une ligne entre deux indices de bougie et deux prix ; renvoie son id.
- `line.set_x1, set_y1, set_x2, set_y2, set_xy1, set_xy2, set_color, set_style, set_width` (line.set_x1, line.set_y1, line.set_x2, line.set_y2, line.set_xy1, line.set_xy2, line.set_color, line.set_style, line.set_width) — Modifie une ligne.
- `line.delete(id)` — Supprime une ligne.
- `box.new(left, top, right, bottom, border_color, bgcolor, extend)` — Dessine un rectangle ; renvoie son id.
- `box.set_left, set_top, set_right, set_bottom, set_bgcolor, set_border_color, set_extend` (box.set_left, box.set_top, box.set_right, box.set_bottom, box.set_bgcolor, box.set_border_color, box.set_extend) — Modifie un cadre.
- `box.delete(id)` — Supprime un cadre.
- `line.style_*, box.style_*` (line.style_solid, line.style_dashed, line.style_dotted, box.style_solid, box.style_dashed, box.style_dotted) — solid, dashed, dotted.
- `extend.*` (extend.none, extend.left, extend.right, extend.both) — none, left, right, both.

### Mathématiques, chaînes et couleurs

- `math.abs, ceil, floor, round(number, precision), sign, sqrt, exp, log, log10, pow(base, exponent)` (math.abs, math.ceil, math.floor, math.round, math.sign, math.sqrt, math.exp, math.log, math.log10, math.pow) — Arithmétique.
- `math.max(...), math.min(...), math.avg(...)` (math.min, math.avg) — Sur un nombre quelconque de valeurs.
- `math.sum(source, length)` — Somme sur les length dernières bougies.
- `math.pi, math.e` (math.pi, math.e) — Constantes.
- `na, na(x), nz(x, replacement), fixnan(x)` (na, nz, fixnan) — La valeur manquante, un test pour elle, un substitut et la dernière valeur non-na.
- `int(x), float(x), bool(x)` (float, bool) — Conversions.
- `str.tostring(value, format), str.format(text, ...), str.length(s), str.contains(s, part)` (str.format, str.length, str.contains) — Chaînes. str.format remplace {0}, {1}… par les arguments.
- `color.new(color, transp), color.rgb(red, green, blue, transp)` (color.rgb) — Construit une couleur ; la transparence va de 0 à 100.
- `color.*` (color.red, color.green, color.blue, color.orange, color.yellow, color.purple, color.aqua, color.lime, color.fuchsia, color.teal, color.maroon, color.navy, color.olive, color.gray, color.silver, color.white, color.black) — red, green, blue, orange, yellow, purple, aqua, lime, fuchsia, teal, maroon, navy, olive, gray, silver, white, black.

### Tableaux (array.*)

- `array.new_float, new_int, new_bool, new_string, new_color, new_line, new_box, new_label, new_table(size)` (array.new_float, array.new_int, array.new_bool, array.new_string, array.new_color, array.new_line, array.new_box, array.new_label, array.new_table) — Crée un tableau.
- `array.get, set, insert, push, pop, shift, unshift` (array.get, array.set, array.insert, array.push, array.pop, array.shift, array.unshift) — Lit et modifie des éléments.
- `array.size, first, last, sum, avg, min, max, stdev` (array.size, array.first, array.last, array.sum, array.avg, array.min, array.max, array.stdev) — Taille et statistiques.

### Maps et types définis par l'utilisateur

Les types définis par l'utilisateur et la collection `map.<fn>` sont pris en charge. Les deux sont des déclarations de premier niveau ; les méthodes d'instance sur une valeur s'écrivent `obj.method(args...)`.

- `enum Name
    Member
    Member = N
    ...` — Déclaration d'enum de premier niveau. Les membres sans valeur s'incrémentent automatiquement depuis 0 ; les valeurs explicites peuvent être des nombres ou des chaînes. On y accède par `Name.Member` dans toute position d'expression. Les valeurs d'enum sont de simples nombres (ou chaînes) : elles fonctionnent avec les opérateurs de comparaison et avec `int()` sans conversion.
- `type Name
    field1
    field2: int
    field3 = default` — Type défini par l'utilisateur, de premier niveau. Les champs se listent un par ligne ; les parties `: type` et `= default` sont acceptées pour la compatibilité future mais pas encore validées. On le construit avec `Type.new(arg1, arg2, ...)` et on lit les champs avec `instance.field`.
- `m = map.new<int, float>()` (map.new) — Crée un map vide. Les arguments de type `<K, V>` sont acceptés mais ignorés à l'exécution.
- `m = map.put(m, key, value)` (map.put) — Définit une clé. Renvoie le map pour que les appels puissent être enchaînés ou réaffectés.
- `v = map.get(m, key)` (map.get) — Lit une valeur. Renvoie na si la clé est absente.
- `n = map.size(m)` (map.size) — Nombre d'entrées.
- `keys = map.keys(m), values = map.values(m)` (map.keys, map.values) — Renvoie les clés ou les valeurs sous forme de tableau Pine (ordre d'insertion).
- `map.contains(m, key), map.remove(m, key)` (map.remove) — Test d'appartenance et suppression. Les deux renvoient le map.

## Pas encore disponible

Une fonction inconnue du moteur interrompt le script avec « Unknown function » et la ligne et la colonne.

- `label.new(), table.new()`: Pas encore disponible. Les lignes et les cadres le sont.
- `import, matrix.*, array.new<type>()`: Les bibliothèques, les matrices et les constructeurs de tableau typés ne sont pas encore implémentés.
- `strategy.risk.*`: Les règles de risque (max_position_size, max_intraday_loss, max_drawdown, allow_entry_in) ne sont pas prises en charge. Les stops suiveurs dans strategy.exit() le sont : utilisez trail_points et trail_offset.

## Exemples exécutables

Scripts fournis qui compilent avec ce moteur :

**RSI Mean Reversion**

```pine
//@version=5
strategy("RSI Mean Reversion", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.1)
len = input.int(14, "RSI length", minval=2)
oversold = input.float(30, "Oversold")
exitLevel = input.float(50, "Exit level")
stopPct = input.float(2, "Stop loss %", minval=0, step=0.1)
tpPct = input.float(6, "Take profit %", minval=0, step=0.1)
if strategy.position_size > 0
    strategy.exit("Risk", stop=stopPct > 0 ? strategy.position_avg_price * (1 - stopPct / 100) : na, limit=tpPct > 0 ? strategy.position_avg_price * (1 + tpPct / 100) : na)
r = ta.rsi(close, len)
if strategy.position_size == 0 and r < oversold
    strategy.entry("Long", strategy.long)
if strategy.position_size > 0 and r > exitLevel
    strategy.close("Long", comment="RSI exit")
plot(r, "RSI", color=color.purple)
hline(oversold, "Oversold", color=color.green)
hline(exitLevel, "Exit", color=color.gray)
```

**MACD Crossover**

```pine
//@version=5
strategy("MACD Crossover", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.1)
fast = input.int(12, "Fast", minval=1)
slow = input.int(26, "Slow", minval=2)
sig = input.int(9, "Signal", minval=1)
stopPct = input.float(2, "Stop loss %", minval=0, step=0.1)
tpPct = input.float(6, "Take profit %", minval=0, step=0.1)
if strategy.position_size > 0
    strategy.exit("Risk", stop=stopPct > 0 ? strategy.position_avg_price * (1 - stopPct / 100) : na, limit=tpPct > 0 ? strategy.position_avg_price * (1 + tpPct / 100) : na)
[m, s, h] = ta.macd(close, fast, slow, sig)
if ta.crossover(m, s)
    strategy.entry("Long", strategy.long)
if ta.crossunder(m, s)
    strategy.close("Long", comment="MACD cross")
plot(h, "Histogram", color=h >= 0 ? color.new(color.green, 40) : color.new(color.red, 40), style=plot.style_columns)
plot(m, "MACD", color=color.orange)
plot(s, "Signal", color=color.blue)
```

**Bollinger Bounce**

```pine
//@version=5
strategy("Bollinger Bounce", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.1)
len = input.int(20, "Length", minval=2)
mult = input.float(2, "StdDev", minval=0.5, step=0.1)
stopPct = input.float(2, "Stop loss %", minval=0, step=0.1)
tpPct = input.float(6, "Take profit %", minval=0, step=0.1)
if strategy.position_size > 0
    strategy.exit("Risk", stop=stopPct > 0 ? strategy.position_avg_price * (1 - stopPct / 100) : na, limit=tpPct > 0 ? strategy.position_avg_price * (1 + tpPct / 100) : na)
[basis, upper, lower] = ta.bb(close, len, mult)
if strategy.position_size == 0 and close <= lower
    strategy.entry("Long", strategy.long)
if strategy.position_size > 0 and close >= basis
    strategy.close("Long", comment="Back to mean")
u = plot(upper, "Upper", color=color.blue)
plot(basis, "Basis", color=color.gray)
l = plot(lower, "Lower", color=color.blue)
fill(u, l, color=color.new(color.blue, 92))
```

## Elsewhere

- Human reference: https://deepwick.com/fr/docs/script
- Try a script with no signup: https://deepwick.com/try