# Deepwick Script

Deepwick Script ist die Sprache der Charts und Backtests von Deepwick. Sie ist eine
**Teilmenge von Pine Script v5/v6**: Die meisten Aufrufe von `ta.*`, `math.*`, `str.*`,
`array.*`, `map.*`, `input.*`, `plot*` und `strategy.*` laufen genau wie in Pine.
Deepwick ist nicht mit TradingView affiliated; Pine Script ist eine Marke der TradingView, Inc.

Ein Script läuft einmal pro Kerze, von der ältesten zur neuesten, und jede Variable
behält ihren Verlauf: dieselbe Seriensemantik wie in Pine.

## Regeln, die beim Erzeugen von Code zählen

- **Sieh dir vor dem Schreiben die Liste der nicht unterstützten Funktionen an.** Ein nicht unterstützter Aufruf ist der teuerste Fehler hier: Die meisten kompilieren und geben stillschweigend `na` zurück, sodass ein Script richtig aussehen und nichts zeichnen kann.
- **`request.security()` funktioniert für eine höhere Zeiteinheit desselben Symbols wie im Chart.** `request.security(syminfo.tickerid, "240", close)` liefert den letzten *geschlossenen* 4h-Schluss, und der Ausdruck darf ein `ta.*`-Aufruf sein. Ein anderes **Symbol** liefert `na`: die Engine hält nur die Kerzen des Charts und holt kein anderes.
- **Kein Blick in die Zukunft.** Der Backtest-Broker füllt einen Auftrag nie mit Daten aus der Zukunft: Market-Orders werden zur *Eröffnung der nächsten Kerze* ausgeführt.
- **Die Kosten sind echt.** Jede Ausführung zahlt Provision und Slippage, wie in `strategy()` deklariert. Eine ohne Kosten profitable Strategie kann mit ihnen unprofitabel sein.
- **Stops und Limits folgen der Kerze**, in der Reihenfolge Eröffnung, näherer Extremwert, entfernterer Extremwert, Schluss. Ein Auftrag, den der Preis mit einem Gap überspringt, wird zur Eröffnung ausgeführt.
- **Deklarieren mit `=`, neu zuweisen mit `:=`.** Nutze `var` für Zustand, der über Kerzen hinweg bestehen muss.
- **Die Einrückung beträgt vier Leerzeichen.** Pine kennt keine geschweiften Klammern; die Blöcke von `if`/`for`/`while`/`switch` sind eingerückte Blöcke.
- **Benannte Argumente kommen zuletzt.** Sobald du `name=` schreibst, müssen alle folgenden Argumente ebenfalls benannt sein: `plotshape(series=x, title="t", style=shape.circle)` ist gültig, `plotshape(x, "t", style=…)` nicht. Ein positionelles Argument nach einem benannten hält das Script mit einem Syntaxfehler an.
- **Ein Ausstieg kann nicht auf der Kerze auslösen, die ihn erteilt hat.** Ein Market-`strategy.entry` wird zur *Eröffnung der nächsten Kerze* ausgeführt, ein `strategy.exit` auf dieser Kerze kann daher erst ab der folgenden fills auslösen. Ein Preis, der auf der erteilenden Kerze bereits unter deinen Stop gefallen ist, wird nicht gegen dich ausgeführt.
- **Ein Ausstieg mit zwei Beinen löst nur einmal aus.** Füllt sich ein Bein von `strategy.exit(stop=…, limit=…)`, wird das andere mit ihm storniert: ein Trade, nie zwei. Erreicht die Kerze beide Niveaus, gewinnt das, das dem Verlauf der Kerze folgend zuerst erreicht wird.
- **Trailing Stops:** `strategy.exit(trail_points=N, trail_offset=M)`. Beides steht in **Ticks**, nicht in Preiseinheiten. `trail_offset` ist der Gewinn, der geräumt sein muss, bevor der Stop scharf wird; `trail_points` ist der Abstand zum besten erreichten Preis. Der Stop ratchet stets nur zu deinen Gunsten und bewegt sich auf geschlossenen Kerzen.

## Funktionsreferenz

Die Signaturen und was jede tut. Die Argumente stehen in der Reihenfolge, in der du sie schreibst.

### Sprache

Deepwick Script führt eine Teilmenge von Pine Script aus, darunter Enums, benutzerdefinierte Typen, Methoden und Maps; die Zeile //@version wird nicht erzwungen. Ein Script läuft einmal pro Kerze, von der ältesten zur neuesten, und jede Variable behält ihren Verlauf.

- `x = expr / x := expr` — Deklariert eine Variable und weist ihr danach mit := einen neuen Wert zu. Ein optionaler Typ (int, float, bool, string, color, series, simple, const, line, label) darf dem Namen vorausgehen.
- `var / varip` — Initialisiert sich einmal auf der ersten Kerze und behält den Wert über die Kerzen hinweg. varip verhält sich wie var, weil Scripts auf geschlossenen Kerzen laufen.
- `x[n]` — Historienoperator: der Wert von x vor n Kerzen (na vor der ersten Kerze).
- `if / else` — Bedingte Blöcke, um vier Leerzeichen eingerückt. if kann auch als Ausdruck verwendet werden.
- `cond ? a : b` — Ternärer Operator.
- `switch` — Mehrfachverzweigung, mit oder ohne zu vergleichenden Wert.
- `for i = a to b [by step]` — Zählschleife. break und continue werden unterstützt.
- `while cond` — Schleife, solange eine Bedingung gilt.
- `f(x, y) => expr` — Benutzerdefinierte Funktion, einzeilig oder als eingerückter Block, dessen letzter Ausdruck zurückgegeben wird. Jede Aufrufstelle behält ihren eigenen ta.*-Zustand, wie in Pine.
- `[a, b] = f()` — Tupel: Funktionen können mehrere Werte zurückgeben, und eingebaute wie ta.macd() und ta.bb() tun das.
- `and / or / not` — Logische Operatoren. Arithmetik: + - * / %; Vergleich: == != < <= > >=.

### Deklarationen

- `indicator(title, shorttitle, overlay, precision)` (study) — Deklariert einen Indikator: Er zeichnet auf dem Chart und hat nichts zu backtesten. study() wird als Alias akzeptiert.
- `strategy(title, overlay, initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, slippage, pyramiding)` — Deklariert eine Strategie. Vorgaben: initial_capital 100000, 1 Kontrakt pro Order, Provision 0, Slippage 0 Ticks, Pyramiding 1. Andere Argumente wie process_orders_on_close werden ignoriert.

### Eingaben

Eingaben erscheinen neben dem Editor und in den Einstellungen des Indikators, damit du sie ändern kannst, ohne den Code anzufassen.

- `input.int(defval, title, minval, maxval, step)` — Ganzzahl.
- `input.float(defval, title, minval, maxval, step)` — Dezimalzahl.
- `input.bool(defval, title)` — Kontrollkästchen.
- `input.string(defval, title, options)` — Text oder eine Liste von Optionen.
- `input.session(defval, title)` — Eine Handelssitzung wie "0930-1600" oder Tage wie "23456". Übergib sie an session.ismarket() und die anderen session.*-Prädikate.
- `input.source(defval, title)` — Eine Preisquelle: open, high, low, close, hl2, hlc3, ohlc4 oder hlcc4.
- `input.color(defval, title)` — Farbwähler.
- `input(defval, title)` — Generische Eingabe; der Typ folgt dem Standardwert.

### Kerzendaten und Zeit

Zeiten sind UTC-Millisekunden. hour() und die anderen Zeitfunktionen nehmen eine optionale Zeit entgegen; hour() nimmt zusätzlich eine Zeitzone aus einer festen Liste von Versatzungen entgegen, ohne Sommerzeit.

- `open, high, low, close, volume` (open, high, low, close, volume) — Preise und Volumen der aktuellen Kerze.
- `hl2, hlc3, ohlc4, hlcc4` (hl2, hlc3, ohlc4, hlcc4) — Übliche Preisdurchschnitte.
- `bar_index, last_bar_index` (bar_index, last_bar_index) — Index der aktuellen Kerze (0 ist die älteste) und der letzten Kerze.
- `time, time_close` (time, time_close) — Eröffnungs- und Schlusszeit der Kerze. Als Funktionen — time("D"), time(timeframe.period, "0000-0900:23456", "UTC") — der Anfang (oder das Ende) der Kerze höherer Zeiteinheit, die diese enthält, oder na, wenn die Kerze außerhalb der Sitzung liegt. Sitzungen: "HHMM-HHMM", auch über Nacht, mehrere durch Kommas getrennte Fenster, optionale Tage nach einem Doppelpunkt (1 = Sonntag … 7 = Samstag), "24x7".
- `timeframe.change(timeframe)` — Wahr auf der ersten Kerze jedes neuen Zeitraums, z. B. timeframe.change("D") auf der ersten Kerze jedes Tages (Wochen beginnen am Montag).
- `timestamp(timezone?, year, month, day, hour, minute, second)` — Eine Zeit in Millisekunden aus ihren Teilen oder aus einem Datumsstring: timestamp("2026-01-05T09:30:00Z").
- `dayofweek.sunday … dayofweek.saturday` (dayofweek.monday, dayofweek.tuesday, dayofweek.wednesday, dayofweek.thursday, dayofweek.friday, dayofweek.saturday) — Tageskonstanten zum Vergleich mit dayofweek (1 … 7).
- `session.ismarket, isfirstbar, islastbar, ispremarket, ispostmarket` (session.ismarket, session.isfirstbar, session.islastbar, session.ispremarket, session.ispostmarket) — Sitzungszustand. Die Märkte hier handeln rund um die Uhr, deshalb liegt jede Kerze in der Marktsitzung; isfirstbar / islastbar markieren die erste und die letzte Kerze jedes UTC-Tages.
- `year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second` (year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second) — Kalenderbestandteile der Kerzenzeit; auch mit einer Zeit aufrufbar, z. B. hour(time, "America/New_York"). dayofweek: 1 = Sonntag … 7 = Samstag.
- `barstate.isfirst, islast, isnew, isconfirmed, ishistory, isrealtime` (barstate.isfirst, barstate.islast, barstate.isnew, barstate.isconfirmed, barstate.ishistory, barstate.isrealtime) — Wo das Script im Kerzenverlauf steht.
- `timeframe.period, multiplier, isintraday, isdaily, isweekly, ismonthly` (timeframe.period, timeframe.multiplier, timeframe.isintraday, timeframe.isdaily, timeframe.isweekly, timeframe.ismonthly) — Die Zeiteinheit des Charts.
- `syminfo.ticker, tickerid, mintick, pointvalue` (syminfo.ticker, syminfo.tickerid, syminfo.mintick, syminfo.pointvalue) — Das Symbol des Charts, seine Preisschrittweite und sein Punktwert.

### Technische Analyse (ta.*)

Jede Aufrufstelle behält ihren eigenen Zustand, wie in Pine: zwei ta.ema()-Aufrufe auf verschiedenen Zeilen sind zwei unabhängige Durchschnitte. Das Ergebnis ist na, bis genügend Kerzen vorliegen.

- `ta.sma(source, length)` — Einfacher gleitender Durchschnitt.
- `ta.ema(source, length)` — Exponentieller gleitender Durchschnitt.
- `ta.rma(source, length)` — Wilder-Durchschnitt, den RSI und ATR verwenden.
- `ta.wma(source, length)` — Gewichteter gleitender Durchschnitt.
- `ta.vwma(source, length)` — Volumengewichteter gleitender Durchschnitt.
- `ta.hma(source, length)` — Hull-Durchschnitt.
- `ta.linreg(source, length, offset)` — Wert der linearen Regressionsgeraden.
- `ta.vwap(source)` — Volumengewichteter Durchschnittspreis, der jeden Tag um 00:00 UTC neu beginnt.
- `ta.rsi(source, length)` — Relative Strength Index, 0 bis 100.
- `ta.macd(source, fastlen, slowlen, siglen)` — Gibt [macd, signal, histogram] zurück.
- `ta.stoch(source, high, low, length)` — Stochastik %K, 0 bis 100.
- `ta.cci(source, length)` — Commodity Channel Index.
- `ta.mfi(series, length)` — Money Flow Index.
- `ta.wpr(length)` — Williams %R, -100 bis 0.
- `ta.dmi(diLength, adxSmoothing)` — Gibt [+DI, -DI, ADX] zurück.
- `ta.supertrend(factor, atrPeriod)` — Gibt [supertrend, direction] zurück; die Richtung ist -1 im Aufwärtstrend und 1 im Abwärtstrend.
- `ta.sar(start, inc, max)` — Parabolischer SAR.
- `ta.mom(source, length)` — Momentum: die Quelle minus die Quelle von vor length Kerzen.
- `ta.roc(source, length)` — Veränderungsrate, in Prozent.
- `ta.change(source, length)` — Differenz zu vor length Kerzen (standardmäßig 1).
- `ta.tr / ta.tr(handle_na)` — True Range.
- `ta.atr(length)` — Average True Range (Wilder).
- `ta.bb(series, length, mult)` — Bollinger-Bänder: gibt [middle, upper, lower] zurück.
- `ta.bbw(series, length, mult)` — Bollinger-Bänderbreite: (upper - lower) / middle.
- `ta.kc(series, length, mult)` — Keltner-Kanäle: gibt [middle, upper, lower] zurück, mit einem EMA der True Range.
- `ta.stdev(source, length, biased)` — Standardabweichung.
- `ta.variance(source, length, biased)` — Varianz.
- `ta.dev(source, length)` — Mittlere absolute Abweichung.
- `ta.median(source, length)` — Median.
- `ta.highest(source, length) / ta.highest(length)` — Höchster Wert über length Kerzen (standardmäßig der high).
- `ta.lowest(source, length) / ta.lowest(length)` — Niedrigster Wert über length Kerzen (standardmäßig der low).
- `ta.highestbars(source, length)` — Versatz zum höchsten Wert: 0 oder negativ.
- `ta.lowestbars(source, length)` — Versatz zum niedrigsten Wert: 0 oder negativ.
- `ta.rising(source, length)` — Wahr, wenn die Quelle über jedem ihrer previous length Werte liegt.
- `ta.falling(source, length)` — Wahr, wenn die Quelle unter jedem ihrer previous length Werte liegt.
- `ta.crossover(source1, source2)` — Wahr auf der Kerze, auf der source1 über source2 kreuzt.
- `ta.crossunder(source1, source2)` — Wahr auf der Kerze, auf der source1 unter source2 kreuzt.
- `ta.cross(source1, source2)` — Wahr bei einem Kreuz in beide Richtungen.
- `ta.pivothigh(source, leftbars, rightbars)` — Der Pivot-High-Preis, bekannt rightbars Kerzen nach dem Pivot; sonst na. Die Quelle ist optional (standardmäßig der high).
- `ta.pivotlow(source, leftbars, rightbars)` — Der Pivot-Low-Preis, bekannt rightbars Kerzen nach dem Pivot; sonst na. Die Quelle ist optional (standardmäßig der low).
- `ta.valuewhen(condition, source, occurrence)` — Wert der Quelle auf dem occurrence-ten zuletzt zurückliegenden Kerzen, auf dem die Bedingung wahr war.
- `ta.barssince(condition)` — Kerzen seit dem letzten Mal, dass die Bedingung wahr war.
- `ta.cum(source)` — Laufende Summe seit der ersten Kerze.

### Strategien (strategy.*)

Market-Orders werden zur Eröffnung der nächsten Kerze ausgeführt. Stop- und Limit-Orders werden entlang der Kerze ausgeführt: Eröffnung, dann das Extrem näher an der Eröffnung, dann das andere Extrem, dann der Schluss. Springt der Preis über eine Order hinweg, wird sie zur Eröffnung ausgeführt. Provision wird bei jeder Ausführung berechnet; Slippage gilt für Market- und Stop-Ausführungen.

- `strategy.entry(id, direction, qty, limit, stop, comment)` — Eröffnet oder erhöht eine Position; Market-Order, sofern nicht limit oder stop angegeben ist.
- `strategy.order(id, direction, qty, limit, stop, comment)` — Dieselben Argumente wie strategy.entry().
- `strategy.exit(id, from_entry, qty_percent, profit, limit, loss, stop, trail_points, trail_offset, comment)` — Take-Profit, Stop-Loss und Trailing Stop für einen Einstieg: Gewinn und Verlust in Ticks, limit und stop als Preise. trail_points ist der Abstand in TICKS vom besten erreichten Preis; trail_offset ist der Gewinn in Ticks, der geräumt sein muss, bevor der Trailing Stop scharf wird. Der Stop ratchet stets nur zu deinen Gunsten und bewegt sich auf GESCHLOSSENEN Kerzen, damit kann eine Kerze nie den Stop auslösen, den ihr eigenes Hoch gesetzt hat.
- `strategy.close(id, comment, qty_percent)` — Schließt einen Einstieg zur nächsten Kerze zum Marktpreis.
- `strategy.close_all(comment)` — Schließt alle offenen Positionen.
- `strategy.cancel(id) / strategy.cancel_all()` (strategy.cancel_all) — Bricht offene Orders ab.
- `strategy.position_size, position_avg_price` (strategy.position_size, strategy.position_avg_price) — Aktuelle Position (positiv long, negativ short) und ihr Durchschnittspreis.
- `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) — Details der offenen Position n (0 = älteste); na, wenn es keine gibt. size ist bei Shorts negativ. Z. B. Ausstieg nach 10 Kerzen: 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) — Details der geschlossenen Position n (0 = älteste; die letzte ist strategy.closedtrades - 1).
- `strategy.equity, netprofit, openprofit, grossprofit, grossloss, initial_capital` (strategy.equity, strategy.netprofit, strategy.openprofit, strategy.grossprofit, strategy.grossloss, strategy.initial_capital) — Kontowerte.
- `strategy.closedtrades, opentrades, wintrades, losstrades` (strategy.closedtrades, strategy.opentrades, strategy.wintrades, strategy.losstrades) — Anzahl der Trades.
- `strategy.long, strategy.short` (strategy.long, strategy.short) — Richtungen.
- `strategy.fixed, strategy.cash, strategy.percent_of_equity` (strategy.fixed, strategy.cash, strategy.percent_of_equity) — Werte für 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) — Werte für commission_type.

### Charts und Alarme

- `plot(series, title, color, linewidth, style)` — Zeichnet eine Serie auf dem Chart oder in einem Fenster.
- `plotshape(series, title, style, location, color, text)` — Zeichnet eine Form auf den Kerzen, auf denen series wahr ist.
- `plotchar(series, title, char, location, color)` — Zeichnet ein Zeichen auf den Kerzen, auf denen series wahr ist.
- `hline(price, title, color, linestyle)` — Waagerechte Linie auf einem festen Niveau.
- `fill(plot1, plot2, color)` — Füllt zwischen zwei Charts oder zwei hlines.
- `bgcolor(color)` — Färbt den Hintergrund der Kerze.
- `barcolor(color)` — Färbt die Kerze selbst.
- `alertcondition(condition, title, message)` — Deklariert eine Bedingung, die du per E-Mail, Telegram, Discord oder webhook zu einem Alarm machen kannst.
- `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. Akzeptiert, aber Formen werden in einer einzigen Größe gezeichnet.

### Linien und Kästen

- `line.new(x1, y1, x2, y2, extend, color, style, width)` — Zeichnet eine Linie zwischen zwei Kerzenindizes und Preisen; gibt ihre id zurück.
- `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) — Ändert eine Linie.
- `line.delete(id)` — Entfernt eine Linie.
- `box.new(left, top, right, bottom, border_color, bgcolor, extend)` — Zeichnet ein Rechteck; gibt seine id zurück.
- `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) — Ändert einen Kasten.
- `box.delete(id)` — Entfernt einen Kasten.
- `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.

### Mathematik, Zeichenketten und Farben

- `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) — Arithmetik.
- `math.max(...), math.min(...), math.avg(...)` (math.min, math.avg) — Über eine beliebige Anzahl von Werten.
- `math.sum(source, length)` — Summe über die letzten length Kerzen.
- `math.pi, math.e` (math.pi, math.e) — Konstanten.
- `na, na(x), nz(x, replacement), fixnan(x)` (na, nz, fixnan) — Der fehlende Wert, ein Test darauf, ein Ersatz dafür und der letzte Wert, der nicht na ist.
- `int(x), float(x), bool(x)` (float, bool) — Konvertierungen.
- `str.tostring(value, format), str.format(text, ...), str.length(s), str.contains(s, part)` (str.format, str.length, str.contains) — Zeichenketten. str.format ersetzt {0}, {1}… durch die Argumente.
- `color.new(color, transp), color.rgb(red, green, blue, transp)` (color.rgb) — Erzeugt eine Farbe; die Transparenz geht von 0 bis 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.

### Arrays (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) — Erzeugt ein Array.
- `array.get, set, insert, push, pop, shift, unshift` (array.get, array.set, array.insert, array.push, array.pop, array.shift, array.unshift) — Liest und ändert Elemente.
- `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) — Größe und Statistik.

### Maps und benutzerdefinierte Typen

Benutzerdefinierte Typen und die Sammlung `map.<fn>` werden unterstützt. Beides sind Deklarationen auf oberster Ebene; Instanzmethoden auf einem Wert nutzen die Syntax `obj.method(args...)`.

- `enum Name
    Member
    Member = N
    ...` — Enum-Deklaration auf oberster Ebene. Mitglieder ohne Wert zählen automatisch ab 0 hoch; explizite Werte dürfen Zahlen oder Zeichenketten sein. Zugriff als `Name.Member` an jeder Stelle eines Ausdrucks. Enum-Werte sind einfache Zahlen (oder Zeichenketten) und funktionieren daher mit Vergleichsoperatoren und mit `int()` ohne Konvertierung.
- `type Name
    field1
    field2: int
    field3 = default` — Benutzerdefinierter Typ auf oberster Ebene. Die Felder stehen einer pro Zeile; die Teile `: type` und `= default` werden für die Kompatibilität akzeptiert, aber noch nicht geprüft. Erzeuge ihn mit `Type.new(arg1, arg2, ...)` und lies Felder mit `instance.field`.
- `m = map.new<int, float>()` (map.new) — Erzeugt eine leere Map. Typargumente `<K, V>` werden akzeptiert, aber zur Laufzeit ignoriert.
- `m = map.put(m, key, value)` (map.put) — Setzt einen Schlüssel. Gibt die Map zurück, damit Aufrufe verkettet oder neu zugewiesen werden können.
- `v = map.get(m, key)` (map.get) — Liest einen Wert. Gibt na zurück, wenn der Schlüssel fehlt.
- `n = map.size(m)` (map.size) — Anzahl der Einträge.
- `keys = map.keys(m), values = map.values(m)` (map.keys, map.values) — Gibt die Schlüssel oder Werte als Pine-Array zurück (Einfügereihenfolge).
- `map.contains(m, key), map.remove(m, key)` (map.remove) — Zugehörigkeitstest und Löschen. Beide geben die Map zurück.

## Noch nicht verfügbar

Eine der Engine unbekannte Funktion stoppt das Script mit „Unknown function“ samt Zeile und Spalte.

- `label.new(), table.new()`: Noch nicht verfügbar. Linien und Kästen schon.
- `import, matrix.*, array.new<type>()`: Bibliotheken, Matrizen und typisierte Array-Konstruktoren sind noch nicht implementiert.
- `strategy.risk.*`: Die Risikoregeln (max_position_size, max_intraday_loss, max_drawdown, allow_entry_in) werden nicht unterstützt. Trailing Stops in strategy.exit() schon: benutze trail_points und trail_offset.

## Ausführbare Beispiele

Mitgelieferte Skripte, die gegen diese Engine kompilieren:

**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/de/docs/script
- Try a script with no signup: https://deepwick.com/try