Documentação

Referência do Deepwick Script

O Deepwick Script é a linguagem dos gráficos e backtests da Deepwick. Executa um subconjunto de Pine Script: a maioria das funções ta.*, math.*, str.*, input.*, plot* e strategy.* funciona tal e qual, e as linhas não suportadas são assinaladas com linha e coluna. Esta página reúne tudo o que o motor admite hoje e o que não admite.

Primeira vez no Deepwick? Comece pelo guia passo a passo: Como fazer backtesting de uma estratégia Pine Script grátis.

A montar uma IA que escreva Deepwick Script? Esta referência num único documento Markdown.

Atualizado: 2026-10-03

Linguagem

O Deepwick Script executa um subconjunto do Pine Script, incluindo enums, tipos definidos pelo utilizador, métodos e maps; a linha //@version não é verificada. Um script executa uma vez por barra, da mais antiga para a mais recente, e cada variável guarda o seu histórico.

Sintaxe	O que faz
`x = expr / x := expr`	Declara uma variável e depois reatribui-a com :=. Pode ser precedida por um tipo opcional (int, float, bool, string, color, series, simple, const, line, label).
`var / varip`	Inicializa uma única vez na primeira barra e mantém o valor entre barras. O varip comporta-se como o var, porque os scripts correm sobre barras fechadas.
`x[n]`	Operador de histórico: o valor de x há n barras (na antes da primeira barra).
`if / else`	Blocos condicionais, com indentação de quatro espaços. O if também pode ser usado como expressão.
`cond ? a : b`	Operador ternário.
`switch`	Ramificação múltipla, com ou sem um valor a comparar.
`for i = a to b [by step]`	Loop com contador. O break e o continue são suportados.
`while cond`	Loop enquanto uma condição se mantiver.
`f(x, y) => expr`	Função definida pelo utilizador, numa linha ou como um bloco indentado cuja última expressão é devolvida. Cada ponto de chamada guarda o seu próprio estado ta.*, tal como no Pine.
`[a, b] = f()`	Tuplas: as funções podem devolver vários valores, e as nativas como ta.macd() e ta.bb() também.
`and / or / not`	Operadores lógicos. Aritmética: + - * / %; comparação: == != < <= > >=.

Declarações

Sintaxe	O que faz
`indicator(title, shorttitle, overlay, precision)`	Declara um indicador: desenha no gráfico e não tem nada para testar. study() é aceite como apelido.
`strategy(title, overlay, initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, slippage, pyramiding)`	Declara a estratégia. Predefinições: initial_capital 100000, 1 contrato por ordem, comissão 0, slippage 0 ticks, pyramiding 1. Outros argumentos, como process_orders_on_close, são ignorados.

Entradas

As entradas aparecem ao lado do editor e nas definições do indicador, para as poderes mudar sem tocar no código.

Sintaxe	O que faz
`input.int(defval, title, minval, maxval, step)`	Número inteiro.
`input.float(defval, title, minval, maxval, step)`	Número decimal.
`input.bool(defval, title)`	Caixa de verificação.
`input.string(defval, title, options)`	Texto, ou uma lista de opções.
`input.session(defval, title)`	Uma sessão de trading como "0930-1600", ou dias como "23456". Passe-a a session.ismarket() e aos outros predicados session.*.
`input.source(defval, title)`	Uma fonte de preço: open, high, low, close, hl2, hlc3, ohlc4 ou hlcc4.
`input.color(defval, title)`	Seletor de cor.
`input(defval, title)`	Entrada genérica; o tipo segue o valor por defeito.

Dados e tempo da barra

Os tempos são milissegundos UTC. hour() e as outras funções de tempo aceitam um tempo opcional; hour() aceita também um fuso horário de uma lista fixa de desvios, sem hora de verão.

Sintaxe	O que faz
`open, high, low, close, volume`	Preços e volume da barra atual.
`hl2, hlc3, ohlc4, hlcc4`	Médias de preço usuais.
`bar_index, last_bar_index`	Índice da barra atual (0 é a mais antiga) e da última barra.
`time, time_close`	Hora de abertura e de fecho da barra. Como funções — time("D"), time(timeframe.period, "0000-0900:23456", "UTC") — o início (ou o fim) da barra de temporalidade maior que contém esta, ou na quando a barra está fora da sessão. Sessões: "HHMM-HHMM", também nocturnas, várias janelas separadas por vírgulas, dias opcionais após dois pontos (1 = domingo … 7 = sábado), "24x7".
`timeframe.change(timeframe)`	Verdadeiro na primeira barra de cada novo período, p. ex. timeframe.change("D") na primeira barra de cada dia (as semanas começam à segunda-feira).
`timestamp(timezone?, year, month, day, hour, minute, second)`	Um tempo em milissegundos a partir das suas partes, ou de uma data em texto: timestamp("2026-01-05T09:30:00Z").
`dayofweek.sunday … dayofweek.saturday`	Constantes de dia para comparar com dayofweek (1 … 7).
`session.ismarket, isfirstbar, islastbar, ispremarket, ispostmarket`	Estado da sessão. Aqui os mercados negociam quase sem parar, por isso cada barra está na sessão de mercado; isfirstbar / islastbar marcam a primeira e a última barra de cada dia UTC.
`year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second`	Partes de calendário da hora da barra; também se podem chamar com um tempo, p. ex. hour(time, "America/New_York"). dayofweek: 1 = domingo … 7 = sábado.
`barstate.isfirst, islast, isnew, isconfirmed, ishistory, isrealtime`	Onde o script está no histórico de barras.
`timeframe.period, multiplier, isintraday, isdaily, isweekly, ismonthly`	A temporalidade do gráfico.
`syminfo.ticker, tickerid, mintick, pointvalue`	O símbolo do gráfico, o seu passo de preço e o seu valor do ponto.

Análise técnica (ta.*)

Cada ponto de chamada guarda o seu próprio estado, tal como no Pine: duas chamadas ta.ema() em linhas diferentes são duas médias independentes. O resultado é na até existirem barras suficientes.

Sintaxe	O que faz
`ta.sma(source, length)`	Média móvel simples.
`ta.ema(source, length)`	Média móvel exponencial.
`ta.rma(source, length)`	Média móvel de Wilder, usada pelo RSI e pelo ATR.
`ta.wma(source, length)`	Média móvel ponderada.
`ta.vwma(source, length)`	Média móvel ponderada pelo volume.
`ta.hma(source, length)`	Média móvel de Hull.
`ta.linreg(source, length, offset)`	Valor da reta de regressão linear.
`ta.vwap(source)`	Preço médio ponderado pelo volume, que reinicia às 00:00 UTC de cada dia.
`ta.rsi(source, length)`	Índice de Força Relativa, de 0 a 100.
`ta.macd(source, fastlen, slowlen, siglen)`	Devolve [macd, signal, histogram].
`ta.stoch(source, high, low, length)`	Estocástico %K, de 0 a 100.
`ta.cci(source, length)`	Índice do Canal de Commodities.
`ta.mfi(series, length)`	Índice de Fluxo de Dinheiro.
`ta.wpr(length)`	Williams %R, de -100 a 0.
`ta.dmi(diLength, adxSmoothing)`	Devolve [+DI, -DI, ADX].
`ta.supertrend(factor, atrPeriod)`	Devolve [supertrend, direction]; a direção é -1 numa tendência de alta e 1 numa de baixa.
`ta.sar(start, inc, max)`	SAR Parabólico.
`ta.mom(source, length)`	Momento: a fonte menos a fonte de há length barras.
`ta.roc(source, length)`	Variação percentual, em percentagem.
`ta.change(source, length)`	Diferença face a há length barras (1 por defeito).
`ta.tr / ta.tr(handle_na)`	True range.
`ta.atr(length)`	Average true range (Wilder).
`ta.bb(series, length, mult)`	Bandas de Bollinger: devolve [middle, upper, lower].
`ta.bbw(series, length, mult)`	Largura das bandas de Bollinger: (upper - lower) / middle.
`ta.kc(series, length, mult)`	Canais de Keltner: devolve [middle, upper, lower], com uma média exponencial do true range.
`ta.stdev(source, length, biased)`	Desvio-padrão.
`ta.variance(source, length, biased)`	Variância.
`ta.dev(source, length)`	Desvio absoluto médio.
`ta.median(source, length)`	Mediana.
`ta.highest(source, length) / ta.highest(length)`	Valor máximo nas últimas length barras (o high por defeito).
`ta.lowest(source, length) / ta.lowest(length)`	Valor mínimo nas últimas length barras (o low por defeito).
`ta.highestbars(source, length)`	Deslocamento até ao valor máximo: 0 ou negativo.
`ta.lowestbars(source, length)`	Deslocamento até ao valor mínimo: 0 ou negativo.
`ta.rising(source, length)`	Verdadeiro se a fonte estiver acima de cada um dos seus length valores anteriores.
`ta.falling(source, length)`	Verdadeiro se a fonte estiver abaixo de cada um dos seus length valores anteriores.
`ta.crossover(source1, source2)`	Verdadeiro na barra em que source1 cruza por cima de source2.
`ta.crossunder(source1, source2)`	Verdadeiro na barra em que source1 cruza por baixo de source2.
`ta.cross(source1, source2)`	Verdadeiro num cruzamento em qualquer direção.
`ta.pivothigh(source, leftbars, rightbars)`	O preço do pivot high, conhecido rightbars barras depois do pivô; na caso contrário. A fonte é opcional (o high por defeito).
`ta.pivotlow(source, leftbars, rightbars)`	O preço do pivot low, conhecido rightbars barras depois do pivô; na caso contrário. A fonte é opcional (o low por defeito).
`ta.valuewhen(condition, source, occurrence)`	Valor da fonte na ocorrência-ésima barra mais recente em que a condição foi verdadeira.
`ta.barssince(condition)`	Barras desde a última vez em que a condição foi verdadeira.
`ta.cum(source)`	Total acumulado desde a primeira barra.

Outras temporalidades (request.*)

Uma temporalidade maior é construída a partir das barras do próprio gráfico, por isso não precisa de dados que o motor não tenha. O valor de uma barra de temporalidade maior só fica visível na barra do gráfico DEPOIS de esta ter fechado: uma barra de 4h nunca se lê de dentro de si mesma, e é isso que mantém um backtest honesto.

Sintaxe O que faz

request.security(symbol, timeframe, expression) Executa expression numa temporalidade maior do MESMO símbolo e devolve o último valor FECHADO. Funciona no próprio símbolo do gráfico (ou syminfo.tickerid, ou um símbolo vazio); outro símbolo devolve na, porque o motor só tem as barras do gráfico. As temporalidades aceitam a notação do Pine ("60", "240", "D", "W", "M") e a do Deepwick ("1h", "4h", "1d"). A expressão pode ser uma chamada ta.*, avaliada sobre a série da temporalidade maior. Devolve na até uma dessas barras ter fechado.

request.security(..., lookahead) Aceite e ignorado. lookahead_on permitiria a um backtest ler a barra de temporalidade maior em formação, o que é olhar para o futuro; o motor nunca espreita. gaps afeta apenas o desenho intra-barra, que aqui não se aplica.

Sintaxe	O que faz
`request.security(symbol, timeframe, expression)`	Executa expression numa temporalidade maior do MESMO símbolo e devolve o último valor FECHADO. Funciona no próprio símbolo do gráfico (ou syminfo.tickerid, ou um símbolo vazio); outro símbolo devolve na, porque o motor só tem as barras do gráfico. As temporalidades aceitam a notação do Pine ("60", "240", "D", "W", "M") e a do Deepwick ("1h", "4h", "1d"). A expressão pode ser uma chamada ta.*, avaliada sobre a série da temporalidade maior. Devolve na até uma dessas barras ter fechado.
`request.security(..., lookahead)`	Aceite e ignorado. lookahead_on permitiria a um backtest ler a barra de temporalidade maior em formação, o que é olhar para o futuro; o motor nunca espreita. gaps afeta apenas o desenho intra-barra, que aqui não se aplica.

Estratégias (strategy.*)

As ordens a mercado executam na abertura da barra seguinte. As ordens stop e limitada executam ao longo da barra: abertura, depois o extremo mais perto da abertura, depois o outro extremo, depois o fecho. Se o preço abrir um intervalo por cima da ordem, executa na abertura. A comissão é cobrada em cada execução; o slippage aplica-se às execuções a mercado e stop.

Sintaxe	O que faz
`strategy.entry(id, direction, qty, limit, stop, comment)`	Abre ou aumenta uma posição; ordem a mercado salvo se for dado limit ou stop.
`strategy.order(id, direction, qty, limit, stop, comment)`	Os mesmos argumentos que strategy.entry().
`strategy.exit(id, from_entry, qty_percent, profit, limit, loss, stop, trail_points, trail_offset, comment)`	Take-profit, stop-loss e trailing stop de uma entrada: lucro e perda em ticks, limit e stop como preços. trail_points é a distância em TICKS desde o melhor preço alcançado; trail_offset é o lucro em ticks que tem de ser limpo antes de o trailing stop armar. O stop só ratcheta a teu favor e move-se em barras FECHADAS, por isso nenhuma barra pode executar o stop que o seu próprio máximo definiu.
`strategy.close(id, comment, qty_percent)`	Fecha uma entrada a mercado na barra seguinte.
`strategy.close_all(comment)`	Fecha todas as posições abertas.
`strategy.cancel(id) / strategy.cancel_all()`	Cancela as ordens pendentes.
`strategy.position_size, position_avg_price`	Posição atual (positiva longa, negativa curta) e o seu preço médio.
`strategy.opentrades.entry_bar_index(n), entry_price, entry_time, entry_id, size, profit, commission, max_runup, max_drawdown`	Detalhes da operação aberta n (0 = a mais antiga); na se não existir. O size é negativo nas curtas. Ex. sair após 10 barras: 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`	Detalhes da operação fechada n (0 = a mais antiga; a última é strategy.closedtrades - 1).
`strategy.equity, netprofit, openprofit, grossprofit, grossloss, initial_capital`	Cifras da conta.
`strategy.closedtrades, opentrades, wintrades, losstrades`	Contagens de operações.
`strategy.long, strategy.short`	Direções.
`strategy.fixed, strategy.cash, strategy.percent_of_equity`	Valores para default_qty_type.
`strategy.commission.percent, cash_per_order, cash_per_contract`	Valores para commission_type.

Gráficos e alertas

Sintaxe	O que faz
`plot(series, title, color, linewidth, style)`	Desenha uma série no gráfico ou num painel.
`plotshape(series, title, style, location, color, text)`	Desenha uma forma nas barras onde series é verdadeira.
`plotchar(series, title, char, location, color)`	Desenha um carácter nas barras onde series é verdadeira.
`hline(price, title, color, linestyle)`	Linha horizontal num nível fixo.
`fill(plot1, plot2, color)`	Preenche entre dois plots ou duas hlines.
`bgcolor(color)`	Colore o fundo da barra.
`barcolor(color)`	Colore a própria barra.
`alertcondition(condition, title, message)`	Declara uma condição que podes converter num alerta por email, Telegram, Discord ou webhook.
`plot.style_*`	line, linebr, stepline, histogram, columns, circles, cross, area.
`hline.style_*`	solid, dashed, dotted.
`shape.*`	triangleup, triangledown, arrowup, arrowdown, circle, xcross, cross, diamond, square, flag, labelup, labeldown.
`location.*`	abovebar, belowbar, top, bottom, absolute.
`size.*`	auto, tiny, small, normal, large, huge. Aceite, mas as formas são desenhadas todas com o mesmo tamanho.

Linhas e caixas

Sintaxe	O que faz
`line.new(x1, y1, x2, y2, extend, color, style, width)`	Desenha uma linha entre dois índices de barra e dois preços; devolve o seu id.
`line.set_x1, set_y1, set_x2, set_y2, set_xy1, set_xy2, set_color, set_style, set_width`	Altera uma linha.
`line.delete(id)`	Remove uma linha.
`box.new(left, top, right, bottom, border_color, bgcolor, extend)`	Desenha um retângulo; devolve o seu id.
`box.set_left, set_top, set_right, set_bottom, set_bgcolor, set_border_color, set_extend`	Altera uma caixa.
`box.delete(id)`	Remove uma caixa.
`line.style_, box.style_`	solid, dashed, dotted.
`extend.*`	none, left, right, both.

Matemática, cadeias de caracteres e cores

Sintaxe	O que faz
`math.abs, ceil, floor, round(number, precision), sign, sqrt, exp, log, log10, pow(base, exponent)`	Aritmética.
`math.max(...), math.min(...), math.avg(...)`	De qualquer número de valores.
`math.sum(source, length)`	Soma nas últimas length barras.
`math.pi, math.e`	Constantes.
`na, na(x), nz(x, replacement), fixnan(x)`	O valor em falta, um teste para ele, uma substituição e o último valor não-na.
`int(x), float(x), bool(x)`	Conversões.
`str.tostring(value, format), str.format(text, ...), str.length(s), str.contains(s, part)`	Cadeias de caracteres. str.format substitui {0}, {1}… pelos argumentos.
`color.new(color, transp), color.rgb(red, green, blue, transp)`	Constrói uma cor; a transparência vai de 0 a 100.
`color.*`	red, green, blue, orange, yellow, purple, aqua, lime, fuchsia, teal, maroon, navy, olive, gray, silver, white, black.

Arrays (array.*)

Sintaxe	O que faz
`array.new_float, new_int, new_bool, new_string, new_color, new_line, new_box, new_label, new_table(size)`	Cria um array.
`array.get, set, insert, push, pop, shift, unshift`	Lê e altera elementos.
`array.size, first, last, sum, avg, min, max, stdev`	Tamanho e estatística.

Maps e tipos definidos pelo utilizador

Os tipos definidos pelo utilizador e a coleção `map.<fn>` são suportados. Ambos são declarações de topo; os métodos de instância sobre um valor usam a sintaxe `obj.method(args...)`.

Sintaxe	O que faz
`enum Name Member Member = N ...`	Declaração de enum de topo. Os membros sem valor incrementam automaticamente desde 0; os valores explícitos podem ser números ou cadeias. Acede-se como `Name.Member` em qualquer posição de expressão. Os valores de enum são números (ou cadeias) simples, por isso funcionam com operadores de comparação e com `int()` sem conversão.
`type Name field1 field2: int field3 = default`	Tipo definido pelo utilizador, de topo. Os campos listam-se um por linha; as partes `: type` e `= default` são aceites para compatibilidade futura mas ainda não são validadas. Constrói-se com `Type.new(arg1, arg2, ...)` e leem-se os campos com `instance.field`.
`m = map.new<int, float>()`	Cria um map vazio. Os argumentos de tipo `<K, V>` são aceites mas ignorados em execução.
`m = map.put(m, key, value)`	Define uma chave. Devolve o map para que as chamadas possam ser encadeadas ou reatribuídas.
`v = map.get(m, key)`	Lê um valor. Devolve na se a chave não existir.
`n = map.size(m)`	Número de entradas.
`keys = map.keys(m), values = map.values(m)`	Devolve as chaves ou os valores como um array do Pine (ordem de inserção).
`map.contains(m, key), map.remove(m, key)`	Teste de pertença e eliminação. Ambos devolvem o map.

Ainda não suportado

Uma função que o motor não conhece interrompe o script com "Unknown function" e a linha e a coluna.

Sintaxe	O que faz
`label.new(), table.new()`	Ainda não disponível. Linhas e caixas já estão.
`import, matrix.*, array.new<type>()`	As bibliotecas, as matrizes e os construtores de array tipados ainda não estão implementados.
`strategy.risk.*`	As regras de risco (max_position_size, max_intraday_loss, max_drawdown, allow_entry_in) não são suportadas. Os trailing stops em strategy.exit() são: usa trail_points e trail_offset.

Perguntas

O Deepwick Script é o mesmo que o Pine Script?

Não. É o motor próprio da Deepwick, que executa um subconjunto do Pine Script: as funções desta página. A maioria das chamadas ta.*, math.*, str.*, input.*, plot* e strategy.* corre tal e qual; as linhas não suportadas são assinaladas com a linha e a coluna. A Deepwick não está afiliada ao TradingView; Pine Script é uma marca registada da TradingView, Inc.

Que funcionalidades do Pine Script é que o Deepwick Script suporta?

O Deepwick Script executa um subconjunto do Pine Script, incluindo enums, tipos definidos pelo utilizador (`type`), declarações de métodos e a coleção `map.*`. Ainda não implementados: as bibliotecas (`import`), `matrix.*` e os construtores de array tipados `array.new<type>()`; o editor assinala-os com a linha e a coluna exatas. A linha //@version não é verificada. Cola um script no editor para veres que linhas correm.

O Deepwick suporta request.security()?

Sim, para uma temporalidade maior do próprio símbolo do gráfico. request.security(syminfo.tickerid, "240", close) devolve o último fecho de 4h FECHADO, e a expressão pode ser uma chamada ta.*. Outro símbolo continua a devolver na: o motor só tem as barras do gráfico, e um número plausível mas errado seria pior do que nenhum.

Porquê que request.security() devolve na nas primeiras barras?

Porque ainda não fechou nenhuma barra de temporalidade maior. Uma barra de 4h só se torna legível na barra do gráfico a seguir ao fecho, e é precisamente isso que impede um backtest de ler uma barra que ainda está a formar-se. Depois de fechar uma, o valor repete-se até a próxima fechar.

Como se executam as ordens da estratégia num backtest?

As ordens a mercado executam na abertura da barra seguinte. Os stops e as limitadas executam ao longo da barra (abertura, extremo mais perto, extremo mais longe, fecho), e uma ordem que o preço ultrapassa por um intervalo executa na abertura. A comissão é cobrada em cada execução e o slippage nas execuções a mercado e stop, tal como definido em strategy(); ambos por defeito a zero.

Onde correm os scripts?

No gráfico, no teu navegador, sobre as barras carregadas no gráfico. Os backtests guardados correm nos servidores da Deepwick sobre até 5.000 barras.