Pine Script v6: math.tanh, math.sum y ta.percentrank

Actualizaciones de Pine Script v6 (2025–2026)

Pine Script v6 sigue siendo la versión vigente en 2026 (no existe v7). Entre los cambios recientes más relevantes para el trader cuantitativo:

• Enero 2026 — request.footprint(): los scripts ahora pueden leer programáticamente POC, VAH, VAL, volumen compra/venta y delta por barra (planes Premium/Ultimate). Directamente relevante para análisis de Volume Profile dentro de Pine.
• Julio 2026 — calc_on_every_history_tick: nuevo parámetro de strategy() que ejecuta cada tick histórico, reduciendo el riesgo de lookahead bias en la simulación.
• Octubre 2025 — timeframe_bars_back: nuevo parámetro en time()/time_close() para resolver barras de timeframe superior.
• Noviembre 2025 — syminfo.isin: ISIN del instrumento disponible como built-in.

Sobre repintado: TradingView documenta que más del 95% de los indicadores existentes exhiben alguna forma de repintado, y clasifica el comportamiento en cuatro categorías. Los scripts publicados que usan lookahead_on sin desplazamiento [1] son moderados. Nuestros indicadores declaran su estado de repintado por herramienta en el repositorio.

1. Introducción al Compilador v6

Pine Script v6 es la última evolución del lenguaje de programación propietario de TradingView. Está diseñado para crear indicadores personalizados y estrategias de backtesting robustas que se ejecutan directamente en la nube. A diferencia de las versiones previas, la versión 6 introduce un analizador de tipos más estricto y un motor de cálculo optimizado que reduce significativamente el tiempo de procesamiento de datos históricos.

Para iniciar cualquier script compatible con el estándar actual, debes incluir la directiva de versión en la línea superior del editor:

//@version=6
indicator("Mi Indicador Gueta", overlay=true)
plot(close, color=color.teal)

2. Tipos de Datos y Estructura Sintáctica

El sistema de tipado de Pine Script v6 se divide en formas fundamentales y formas de serie. Las variables pueden ser declaradas de forma explícita para evitar errores de compilación o dejar que el compilador infiera el tipo dinámicamente.

Es un estándar fundamental de buenas prácticas declarar de forma estricta las variables numéricas y los booleanos cuando se construyen reglas de riesgo complejas:

3. Regla Práctica: Media Móvil Simple

Las funciones integradas en la versión 6 de Pine Script requieren que las variables que alimentan sus parámetros estén correctamente formateadas. El siguiente script calcula un filtro de media móvil simple (SMA) utilizando una validación condicional estricta.

//@version=6
indicator("Filtro Cuantitativo Gueta", overlay=true)

// Configuración de parámetros
int period = input.int(20, title="Periodo de Cálculo")
float source = input.source(close, title="Fuente de Precio")

// Cálculo de la Media Móvil
float maValue = ta.sma(source, period)

// Regla de coloración
color maColor = source > maValue ? color.green : color.red

plot(maValue, title="Media Gueta", color=maColor, linewidth=2)

En este ejemplo, la constante period define la ventana del cálculo del promedio móvil. Mantener un riesgo controlado del 1.5% por operación complementa este tipo de análisis técnico.

4. Tutorial Avanzado: Salida Dinámica por ATR (Average True Range)

Una de las grandes ventajas de Pine Script v6 es su capacidad para calcular stop-loss adaptativos basados en volatilidad real. El indicador ATR mide la fuerza del movimiento del mercado. A continuación, te mostramos cómo programar un stop trailing dinámico:

//@version=6
indicator("Stop Trailing ATR Gueta", overlay=true)

int atrLength = input.int(14, title="Periodo ATR")
float atrMultiplier = input.float(2.0, title="Multiplicador ATR")

// Cálculo de ATR
float atrValue = ta.atr(atrLength)
float stopPrice = close - (atrValue * atrMultiplier)

// Asegurar que el trailing stop solo suba en una posición de compra
var float trailingStop = na
trailingStop := not na(trailingStop[1]) ? math.max(stopPrice, trailingStop[1]) : stopPrice

plot(trailingStop, title="Trailing Stop ATR", color=color.orange, style=plot.style_linebr)

Este bloque de código define un stop que se ajusta automáticamente a medida que el precio se mueve a favor de la operación, reduciendo las pérdidas potenciales ante giros rápidos del mercado financiero.

4b. Normalización de Señales con math.tanh() en Pine Script v6

La función math.tanh(x) aplica la tangente hiperbólica matemática sobre cualquier serie numérica para comprimir y acotar sus valores estrictamente en el intervalo (-1.0, +1.0). En trading cuantitativo, es la herramienta estándar para normalizar osciladores de volatilidad, evitar explosiones de valores atípicos y estandarizar señales antes de enviarlas a modelos de ejecución o Webhooks.

En Pine Script v6, math.tanh() opera directamente sobre tipos series float con alta eficiencia computacional:

//@version=6
indicator("Normalizador de Señales con math.tanh() - Gueta Quant", overlay=false)

int lengthInput       = input.int(50, title="Período SMA Base")
float scaleMultiplier = input.float(10.0, title="Multiplicador de Sensibilidad")

// 1. Cálculo de la desviación porcentual del precio
float baseSMA = ta.sma(close, lengthInput)
float rawDeviation = (close - baseSMA) / baseSMA * scaleMultiplier

// 2. Normalización asintótica estricta entre -1.0 y +1.0
float normalizedOscillator = math.tanh(rawDeviation)

// 3. Bandas de saturación cuantitativa
hline(0.8, "Saturación Compradora (+0.8)", color=color.red, linestyle=hline.style_dashed)
hline(0.0, "Nivel de Equilibrio Cero", color=color.gray, linestyle=hline.style_dotted)
hline(-0.8, "Saturación Vendedora (-0.8)", color=color.green, linestyle=hline.style_dashed)

color signalColor = normalizedOscillator > 0.8 ? color.red : normalizedOscillator < -0.8 ? color.green : color.teal
plot(normalizedOscillator, title="Oscilador Tanh v6", color=signalColor, linewidth=2)

4c. Acumulación y Percentiles: math.sum() y ta.percentrank()

Dos funciones indispensables en el análisis cuantitativo de volumen y precio en Pine Script v6 son math.sum() y ta.percentrank():

• math.sum(source, length): Calcula la suma acumulada de una serie float en una ventana móvil de N barras. Reemplaza las funciones de acumulación dispersas de versiones anteriores con tipado estricto.
• ta.percentrank(source, length): Devuelve la posición percentil (0.0 a 100.0) del valor actual relativo a su historial de N barras. Permite identificar anomalías estadísticas sin asumir distribución normal.

//@version=6
indicator("Acumulación math.sum() y Percentiles ta.percentrank() - Gueta Quant", overlay=false)

int volumeWindow = input.int(20, title="Ventana Suma Volumen")
int priceWindow  = input.int(100, title="Ventana Percentil Precio")

// math.sum() para acumular volumen total en 20 barras
float rollingVolSum = math.sum(volume, volumeWindow)
float avgBarVol     = rollingVolSum / volumeWindow

// ta.percentrank() para medir si el precio actual está en máximos o mínimos estadísticos
float priceRank = ta.percentrank(close, priceWindow)

// Visualización de zonas críticas
hline(80.0, "Percentil 80% (Zona Superior)", color=color.orange, linestyle=hline.style_dashed)
hline(20.0, "Percentil 20% (Zona Inferior)", color=color.blue, linestyle=hline.style_dashed)

plot(priceRank, title="Rango Percentil del Precio", color=color.purple, linewidth=2)
plotshape(volume > avgBarVol * 1.8, title="Pico de Volumen Sumado", style=shape.diamond, location=location.top, color=color.yellow, size=size.tiny)

5. Backtesting de Alta Precisión y Mitigación de Sesgos (Look-ahead Bias)

El "Look-ahead Bias" (o sesgo de anticipación) es el error más recurrente y destructivo en el desarrollo de trading cuantitativo. Ocurre cuando un script utiliza información del futuro para tomar decisiones de trading. En TradingView, esto genera curvas de rendimiento perfectas en el simulador que fracasan rotundamente al ejecutarse en tiempo real.

5.1 Evitando la Fuga de Datos (Data Leakage)

Para evitar por completo este sesgo y asegurar que el backtest represente la operativa real, se deben aplicar dos reglas obligatorias en la arquitectura de request.security(): el uso de la referencia desplazada [1] en la serie solicitada y la desactivación explícita mediante lookahead=barmerge.lookahead_off.

//@version=6
strategy("Gueta Quant - Antídoto Look-Ahead Bias", overlay=true, initial_capital=10000000, default_qty_type=strategy.percent_of_equity, default_qty_value=10)

string timeframeSuperior = input.timeframe("D", title="Temporalidad Superior MTF")
bool usarFiltroCorrecto  = input.bool(true, title="Activar Filtro Correcto (Sin Sesgo)")

float cierreDiarioSesgado  = request.security(syminfo.tickerid, timeframeSuperior, close, lookahead=barmerge.lookahead_on)
float cierreDiarioCorrecto = request.security(syminfo.tickerid, timeframeSuperior, close[1], lookahead=barmerge.lookahead_off)
float precioReferencia = usarFiltroCorrecto ? cierreDiarioCorrecto : cierreDiarioSesgado

float maLocal = ta.sma(close, 20)
bool señalLargo = close > maLocal and close > precioReferencia
bool salidaLargo = close < maLocal

if señalLargo and (strategy.position_size == 0)
    strategy.entry("Largo MTF", strategy.long)

if strategy.position_size > 0 and salidaLargo
    strategy.close("Largo MTF")

plot(maLocal, color=color.blue)
plot(precioReferencia, color=usarFiltroCorrecto ? color.green : color.red, linewidth=2)

6. Depuración Profesional mediante el Espacio de Nombres log

Uno de los mayores desafíos para los desarrolladores era la falta de un entorno de depuración interactivo en tiempo de ejecución. Anteriormente, dependíamos de pintar etiquetas (label.new) en el gráfico para inspeccionar variables, lo cual ralentizaba la plataforma.

Pine Script v6 soluciona esto introduciendo el espacio de nombres log, el cual permite escribir mensajes directamente en la consola "Pine Logs" del editor mediante log.info(message), log.warning(message) y log.error(message).

//@version=6
indicator("Gueta Quant - Filtro de Volatilidad v6", overlay=false)

int lengthInput      = input.int(20, title="Período de Volatilidad")
float thresholdInput = input.float(1.5, title="Umbral de Desviación")
bool enableLogs      = input.bool(true, title="Habilitar Depuración en Consola")

float priceClose = close
float basis      = ta.sma(priceClose, lengthInput)
float dev        = ta.stdev(priceClose, lengthInput)
float thresholdValue = float(thresholdInput)

float volumeSeries = volume
float volumeAverage = ta.sma(volumeSeries, lengthInput)
bool isHighVolume = volumeSeries > volumeAverage
bool isVolatilityAlert = (dev > (basis * thresholdValue / 100.0)) and isHighVolume

if enableLogs and (bar_index > last_bar_index - 100)
    string logMessage = "Barra #" + str.tostring(bar_index) + " | Cierre: " + str.tostring(priceClose) + " | Desviación: " + str.tostring(dev)
    if isVolatilityAlert
        log.info(logMessage)
    else if dev > (basis * thresholdValue / 100.0)
        log.warning("Volatilidad alta sin volumen en barra " + str.tostring(bar_index))

color dynamicColor = isVolatilityAlert ? color.rgb(34, 196, 138) : color.rgb(239, 68, 68)
plot(dev, title="Desviación Estándar Filtrada", color=dynamicColor, style=plot.style_columns)

7. Estructuras de Datos Avanzadas (Arrays y Maps)

El análisis cuantitativo profesional exige modelar la información de forma compleja. En Pine Script v6, las estructuras de datos avanzadas permiten simular carteras, gestionar historiales de órdenes y procesar perfiles de volumen de forma óptima sin recurrir a variables sueltas y dispersas.

Los arrays son colecciones ordenadas del mismo tipo de datos, ideales para almacenar registros dinámicos de transacciones. Por otro lado, los mapas (map) representan una adición fundamental para almacenar datos relacionales indexados por claves únicas (como nombres de activos, niveles de precio o identificadores de órdenes).

//@version=6
indicator("Gueta Quant - Gestor de Riesgo Multiactivo", overlay=true)

type Posicion
    string activo
    float precioEntrada
    float tamañoLote
    float stopLoss
    int barraApertura

float capitalCuenta    = input.float(100000.0, title="Capital Total de la Cuenta (USD)")
float riesgoPorcentaje = input.float(1.0, title="Riesgo Máximo por Operación (%)")

var Posicion[] historialPosiciones = array.new()
var map riesgoActivosMap = map.new()

if barstate.isfirst
    map.put(riesgoActivosMap, "BCOLOMBIA", 0.015)
    map.put(riesgoActivosMap, "ECOPETROL", 0.020)
    map.put(riesgoActivosMap, "COLCAP", 0.010)

float fastMA = ta.sma(close, 9)
float slowMA = ta.sma(close, 21)
bool señalCompra = ta.crossover(fastMA, slowMA)

float atrValue = ta.atr(14)
float stopLossCalculado = close - (atrValue * 2.0)
string tickerLimpio = syminfo.ticker
float riesgoEspecifico = map.contains(riesgoActivosMap, tickerLimpio) ? map.get(riesgoActivosMap, tickerLimpio) : (riesgoPorcentaje / 100.0)

float distanciaPrecio = close - stopLossCalculado
float tamañoPosicionCalculado = 0.0
if distanciaPrecio > 0
    tamañoPosicionCalculado := (capitalCuenta * riesgoEspecifico) / distanciaPrecio

if señalCompra and tamañoPosicionCalculado > 0
    Posicion nuevaOp = Posicion.new(tickerLimpio, close, tamañoPosicionCalculado, stopLossCalculado, bar_index)
    array.push(historialPosiciones, nuevaOp)

if barstate.islast and array.size(historialPosiciones) > 0
    Posicion ultimaPos = array.get(historialPosiciones, array.size(historialPosiciones) - 1)
    label.new(x=bar_index, y=high, text="Último Trade: " + ultimaPos.activo + "\nLote: " + str.tostring(ultimaPos.tamañoLote, "#.##"), color=color.black, textcolor=color.white)

8. Ejecución en Tiempo Real y Conectividad con APIs (Webhooks)

La transmisión de alertas automatizadas mediante Webhooks dinámicos es el estándar para conectar TradingView con brokers externos. El motor de TradingView ejecuta el script en la nube y envía solicitudes HTTP POST en formato JSON a microservicios intermediarios que traducen la petición a protocolos de corretaje (API REST o FIX).

Es fundamental dar formato a los parámetros dinámicos (como el tamaño de la posición o el precio de ejecución) controlando el número de decimales mediante str.tostring() para evitar errores de deserialización en las APIs de destino.

//@version=6
strategy("Sistema de Conectividad API - Gueta Quant", overlay=true, initial_capital=10000)

string api_token    = input.string("GUETA_SECURE_AUTH_TOKEN_XYZ", title="Token de Autenticación API")
string broker_route = input.string("LITEFINANCE_CO", title="Ruta del Broker")

bool signal_buy  = ta.crossover(ta.sma(close, 10), ta.sma(close, 20))
bool signal_sell = ta.crossunder(ta.sma(close, 10), ta.sma(close, 20))

fn_build_json(string action, float order_qty, float current_price) =>
    "{" +
    "\"auth_token\": \"" + api_token + "\"," +
    "\"symbol\": \"" + syminfo.ticker + "\"," +
    "\"action\": \"" + action + "\"," +
    "\"quantity\": " + str.tostring(order_qty, "#.##") + "," +
    "\"execution_price\": " + str.tostring(current_price, "#.##") +
    "}"

float size_to_execute = (strategy.equity * 0.02) / close

if (signal_buy)
    string buy_json = fn_build_json("BUY", size_to_execute, close)
    strategy.entry("Long", strategy.long, alert_message=buy_json)

if (signal_sell)
    string sell_json = fn_build_json("SELL", size_to_execute, close)
    strategy.entry("Short", strategy.short, alert_message=sell_json)

9. Gestión Cuantitativa de Riesgo (Drawdown y Dimensionamiento)

El éxito de un sistema algorítmico depende de la consistencia matemática de su riesgo. El tamaño de la posición debe calcularse en base al capital disponible y a la volatilidad medida por el ATR. Adicionalmente, implementar un interruptor de parada de emergencia (Breaker Switch) basado en el drawdown máximo de la cuenta protege el portafolio de pérdidas severas de capital. Si prefiere no programar este cálculo, use nuestra calculadora de lotaje gratuita para MetaTrader 4 y 5, o revise la guía de tamaño de posición en trading.

//@version=6
strategy("Estrategia Cuantitativa de Riesgo Controlado - Gueta Quant", overlay=true, initial_capital=100000, default_qty_type=strategy.cash)

float risk_percent    = input.float(1.5, title="Riesgo por Operación (%)") / 100.0
float max_drawdown_pct = input.float(5.0, title="Límite de Drawdown Portafolio (%)") / 100.0
int atr_period        = input.int(14, title="Periodo ATR")
float atr_multiplier  = input.float(2.0, title="Multiplicador ATR")

float current_atr = ta.atr(atr_period)
var float max_equity = strategy.initial_capital
max_equity := math.max(max_equity, strategy.equity)

float current_drawdown = (max_equity - strategy.equity) / max_equity
bool system_halted = current_drawdown >= max_drawdown_pct

bool entry_long_cond  = ta.crossover(ta.ema(close, 20), ta.ema(close, 50))
bool entry_short_cond = ta.crossunder(ta.ema(close, 20), ta.ema(close, 50))

float stop_distance_ticks = current_atr * atr_multiplier
float target_risk_usd     = strategy.equity * risk_percent
float calculated_size     = target_risk_usd / stop_distance_ticks

if (not system_halted)
    if (entry_long_cond and strategy.position_size == 0)
        strategy.entry("Largo Cuant", strategy.long, qty=calculated_size)
        strategy.exit("Salida Largo", "Largo Cuant", stop=close - stop_distance_ticks)
    if (entry_short_cond and strategy.position_size == 0)
        strategy.entry("Corto Cuant", strategy.short, qty=calculated_size)
        strategy.exit("Salida Corto", "Corto Cuant", stop=close + stop_distance_ticks)
else
    if (strategy.position_size != 0)
        strategy.close_all(comment="CIRCUITO DE RIESGO ACTIVADO: LIQUIDACIÓN")

plot(max_equity, title="Máximo Histórico de Equity", color=color.green, style=plot.style_stepline)
plot(strategy.equity, title="Equidad Actual", color=color.blue)

10. Errores Comunes de Compilación en la Versión 6

El compilador v6 de TradingView es mucho más estricto con los tipos de datos y la declaración de variables. Te presentamos los errores más recurrentes y sus soluciones directas:

11. Cambios de Pine Script v5 a v6: Lista de Migración

Si tienes scripts escritos en v5 y aparecen errores de compilación al cambiar la declaración a //@version=6, esta es la lista de cambios que debes revisar:

• Operadores lógicos: and, or y not se conservan, pero en v6 evalúan con cortocircuito (short-circuit), como en la mayoría de lenguajes de programación.
• Tipado estricto: el compilador valida tipos en asignaciones de arrays y maps; declara el tipo genérico explícitamente (array<float>).
• Espacio math.*: funciones como math.tanh(), math.pow() y math.sum() reemplazan utilidades dispersas de versiones anteriores.
• Límites de etiquetas: el máximo permitido de max_labels_count subió a 500 en v6; el valor por defecto sigue siendo 50.
• Renombres: ta.percentrank() conserva su firma, pero requiere argumentos de tipo series float explícitos en v6.
• Métodos de colección: array.insert(), map.put() y operadores de acceso indexado tienen nuevas sobrecargas; revisa los mensajes del compilador.

La estrategia de migración segura: compila en v5 con advertencias, migra sección por sección y usa log.info() para comparar salidas antes/después en el Strategy Tester.

12. max_labels_count: Límites de Etiquetas en v6

El máximo permitido de etiquetas visuales por script subió de 50 (v5) a 500 en v6; el valor por defecto sigue siendo 50. Cuando superas el máximo, TradingView elimina las etiquetas más antiguas automáticamente. Configúralo con la directiva max_labels_count:

//@version=6
indicator("max_labels_count demo", overlay = true, max_labels_count = 500)

// Marca solo los últimos 500 pivotes sin saturar el gráfico
pivotHigh = ta.pivothigh(high, 5, 5)
if pivotHigh
    label.new(bar_index, high, "PH " + str.tostring(pivotHigh), style = label.style_label_down, color = color.new(color.red, 20))

Relacionado: max_boxes_count, max_lines_count y max_tables_count tienen límites equivalentes que puedes ajustar en la directiva indicator().

Funciones Esenciales de Pine Script v6: Referencia Rápida

Tabla de referencia de las funciones más utilizadas en indicadores y estrategias v6, con su propósito y un ejemplo mínimo de sintaxis.

Todos los ejemplos usan //@version=6. Para ver el código completo de cada función, revise las secciones 11 a 15 de este manual o el repositorio open source de Pine Script en GitHub.